AppleScript_ The Definitive Guide - Matt Neuburg [155]
The solution to this entire issue is: Don't Do That. Simply don't talk like this:
repeat with x in every class
AppleScript's response to this way of talking may have been intended as an optimization, but it's just a mess. The simple solution is to gather the list explicitly, in the same line or an earlier line. So, say this:
repeat with x in (get every class)
Or this:
set L to (get every class)
repeat with x in L
All the problems with repeat with...in vanish in a puff of smoke if you do this. You ask for the list just once, at the start of the loop. That's the only time the application has to form the list, so execution is far less wasteful. You actually obtain the list you ask for, so you're looping through what you think you're looping through. So, for instance, this works properly:
tell application "Finder"
repeat with x in (get every folder) -- loops 6 times, as expected
And here's a quick, efficient, and correctly working version of our BBEdit script:
tell application "BBEdit"
set L to (get every word of document 1 where its text begins with "t")
repeat with w in (reverse of L)
set text of w to "howdy"
end repeat
end tell
Tell
A tell block , like an if block, comes in two forms: a genuine block and a single-line version. The block form is like this:
tell target
-- code targeting this target
end tell
The single-line version is like this:
tell target tocommand
A tell block performs two distinct functions:
It determines (at runtime) the target of the commands within the block.
It dictates (at compile time) the source that will be used for the resolution of the terminology that appears within the block.
The fact that a tell block does both these things makes a certain sense. After all, if you're going to be sending messages to the Finder, you're probably going to want to use the Finder's terminology. Nevertheless, the two functions are distinct, and it is possible to do either one without the other:
To target an application without resolving any terminology, address it entirely by means of of, without using tell:
get frontmost of application "Finder" -- false
That works because the term frontmost is defined by AppleScript itself, so there is no terminology to resolve; the Finder is targeted and a reply comes back.
To resolve an application's terminology without targeting it, use a terms block (see the next section, "Using Terms From"):
using terms from application "Finder"
set f to a reference to folder 1
end using terms from
That works because the terms block uses the Finder's dictionary to resolve the term folder; the Finder is not targeted (we're just forming a reference).
If the target in a tell block is an application, that application can be expressed as a variable rather than a literal application specifier. This variable may have as its value an application specifier, or it might be a reference to an object belonging to an application. Or, the target could be an application specifier, but the name of the application is a string variable instead of a literal string. In these situations, you'll probably have to use a terms block in order to get the code inside the tell block to compile.
On the need for a target application to be present at compile time, decompile time, and runtime, see "Missing External Referents" in Chapter 3. On determination of the target, see Chapter 11. On resolution of terminology, see Chapter 20.
Using Terms From
A terms block has the following structure:
using terms from application
-- code containing terms to be resolved
end using terms from
A terms block dictates which application's dictionary AppleScript should get the enclosed terminology from, without actually targeting that application. Terminology is resolved at compile time; therefore the application must be a literal application specifier (otherwise there's a compile-time error, "Can't make some data