 The loop special form, just like let, creates local bindings to symbols for the duration of a body. The difference is that, like an FN form, the loop form establishes a recursion point for the recurve form. A recurve form and tail position of a loop body jumps execution back to the start of the loop, with new values bound to the symbols. Effectively, loop and recurve used together allow us to repeatedly iterate over a body of code without the bother of creating one-off functions just for the sake of looping. So here, for example, in the first iteration of the loop, 5 is bound to x and 2 is bound to y, and in each successive iteration, the value of x is incremented and the value of y is decremented until x is no longer less than 9. So this loop will print 5, 2, then 6, 1, then 7, 0, then 8, negative 1, then 9, negative 2, and then in the final iteration, the if will return nil, and so the loop will return nil. We could express the same thing as a function which we immediately invoke, like so. The loop form, however, is less verbose. Now, be clear that local symbol bindings and closure are always immutable, so you should think of each symbol binding of a loop as being created anew for each iteration. This subtle distinction matters when we create a function in a loop body. Each iteration of the loop creates a different function object, each seeing different bindings of the enclosing loop. This loop here, for example, creates and returns a vector of functions, each of which prints the value of x for the iteration in which it was created. You should think of each of these function objects as bound to its own immutable value of x, not a single x variable that changes. The quote special form takes just one expression, which it returns un-evaluated, meaning it returns lists and symbols as themselves. List do not get evaluated as function calls, macro calls, or special forms, and the symbols do not get resolved to vars or local bindings. As we'll see later, the quote form is useful mainly in macros, which are meant to return un-evaluated reader data. Some functions, though, expect to receive lists and symbols arguments, so quote is also useful when calling those functions. Here, for example, foo bar passes the value resolved from bar to foo, but if we quote bar, then the symbol bar itself is passed to foo. Likewise here, foo is passed the value returned by the expression bar74, but in the second example, foo is passed a list containing the symbol bar and the number 7 and 4. Because quote is used frequently enough in certain contexts, the reader provides special syntax for the quote form. A reader element preceded by a single quote mark is implicitly enclosed in a quote form. The throw special form takes one expression that returns an exception object to throw. The try special form catches exceptions that propagate from its body. Each catch clause of a try specifies a class of exception to catch, a symbol to which to bind the exception object and a body to execute when that exception is caught. In this example, if the expressions foo or baz propagate an exception of type bad thing, it is caught by the first catch clause. If the expressions propagate an exception of type other bad thing, it is caught by the second catch clause. Just like in Java, a try may end with a finally clause after the catch clauses. Even if an exception propagates out of our try, the finally clause body will always execute as the try's last order of business. When a symbol is resolved to a var in a namespace, it returns the value held by the var. If we want the var object itself, however, we must use the var special form. There aren't many cases where we need the var special form, but it is occasionally useful. The new form returns a new instance of a Java class by invoking its constructor. The class is specified by a symbol matching its name. The dot special form, just a plain period, returns the value of Java object fields and invokes Java methods. To retrieve the value of the static field with the dot form, we write dot class field, where class and field are symbols that match a class and its static field by name. For example, this retrieves the value of the static field pi of the class Java dot lang dot math. For retrieving instance fields, we replace the class name symbol with an expression returning an instance. For example, here we return the bar field of the instance foo with dot foo bar. In the second example, the instance is returned from a call to some function, ak. At runtime, if these expressions don't return a Java object with a field bar, then these dot forms will throw an exception. If the second element of a dot form is a list, the dot form invokes a Java method. The symbol that starts its list names the method and the remaining elements are expressions passed as arguments. Here, we invoke the static method a10 of the math class, and then we invoke the instance method bar of some object foo. The set special form assigns the result of an expression to the instance field or static field specified by a dot form. In the first example, we set the value of the static field pi to 3. In the second example, we assign 3 to the field bar of the instance foo. Be clear that the dot form inside set is evaluated in a special way because the specified field of the dot form is being assigned to not retrieved. If the field we're trying to set is not public or is declared final, the set form will throw an exception. The pi field of java.lang.math is in fact a final field, and so this first set form will throw an exception. Lastly, you can ignore the monitor enter and monitor exit special forms. They are used by the standard library for thread synchronization, but they're not really intended for direct use by closure programmers.