Section 19.3. Tell

19.3. 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 to command

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.