Expressions

Expressions are the syntactic building blocks of Nu. Expressions are written and represented internally as lists. Expressions are sequences of symbols, numbers, and strings enclosed in parentheses. Expressions frequently also contain other expressions.

(a first level expression may contain
   (a second level expression that contains
       (a third level expression
          (and this can continue arbitrarily))))

Operators

When an expression is evaluated, the first element of the expression is examined and evaluated. Usually that first element is a symbol, and often when that symbol is evaluated, it corresponds to an operator. When this occurs, the operator is evaluated with the rest of the expression as its arguments.

In general, an operator may or may not evaluate its arguments and sometimes may evaluate its arguments multiple times. This allows Nu to implement common control structures such as while and if as operators.

For a special class of operators, called functions, all of the arguments are evaluated before the function itself is evaluated. The function is then evaluated with the evaluated arguments. As a result, an expression like (+ 2 (- 4 2)) becomes (+ 2 2) and then 4.

Operators can be defined in Nu code using the function and do operators, which both create functions, and the macro operator, which creates more general operators.

Messages

Everything in Nu is an object, and every object in Nu responds to messages.
Nu's messaging system is built on Objective-C, and Nu code can send messages to objects whether those messages were written in Nu or Objective-C. Similarly, Objective-C code can send messages to objects with no regard for their implementation language. Frequently classes will include methods written in both languages.

The Nu message sending syntax is identical to its function call syntax. A message send is a list. The first element of the list is the target of the message and the rest of the list describes the message. Messages that have no arguments look like this:

(array count)

Messages that have a single argument look like this:

(array objectAtIndex: 1)

Here the second element of the list is a label that is also called the message selector. Immediately following the label is the message's argument.

Messages with multiple arguments look like this:

(array writeToFile:"myfile" atomically:NO)

Here the writeToFile: and atomically: labels together form the message selector writeToFile:atomically:. Each label is followed by an associated argument, in this case the string "myfile" and the symbol NO which is globally defined to zero.

In Nu, operator calls have a higher precedence than message sends. But it is still possible to send messages to operators using the send operator. Here is an example that uses the send operator to get the context of a block.

% (set y 32)
32
% (set block (do (x) (+ 1 y)))
(do (x) ((+ 1 y)))
% (send block context)

% ((send block context) description)
{
    y = 32; 
    ... implementation details...
}

Quoted Lists

Normally, Nu evaluates lists that are defined in Nu source text; these lists represent operator calls and message sends. But sometimes lists are used to represent data. In these cases, the quote operator can be used to prevent evaluation.

(quote (1 2 3))

As a convenience, the single quote character can be used to equivalently quote objects.

'(1 2 3)

quote can also be used on objects besides lists; often it is used to refer to a symbol without evaluating it.

Quasiquote

The quasiquote operator is similar to Nu's quote operator, except that quasiquote allows evaluation of selected subforms within the quasiquoted form by using quasiquote-eval or quasiquote-splice. Each of the quasiquote operators has a convenient abbreviation that is commonly used in place of the spelled-out operator name:

By itself, quasiquote works just like quote:

% `(a b c)
(a b c)

quasiquote-eval can be used to turn on evaluation for selected subforms:

% (set a 1)
1
% (set b 2)
2

% ; turn on evaluation for b
% `(a ,b c)
(a 2 c)

A more complex evaluation:

% `(x y z ,a ,b ,(+ a b))
(x y z 1 2 3)

quasiquote-splice also evaluates its form, but it differs from quasiquote-eval in how the result is returned. With quasiquote-splice, the evaluation must return a list. This list is then "spliced" in-line within the surrounding form of the caller by inserting the contents of the list (not the list itself) into the caller's list:

% ; Using quasiquote-eval:
% `(1 ,(list 2 3))
(1 (2 3))

% ; Using quasiquote-splice:
% `(1 ,@(list 2 3))
(1 2 3)

Neither quasiquote-eval nor quasiquote-splice can be used outside of a quasiquote form.

% (list 1 ,a)
NuQuasiquoteEvalOutsideQuasiquote: Comma must be inside a backquote

The quasiquote operators are particularly useful when writing macros, as the code in the macro body ends up looking much closer to the code that the macro-expansion phase generates.