Next: Property access using colon notation, Previous: Hash-prefixed forms, Up: Syntax [Contents][Index]
expression ::= literal-expression | variable-reference | procedure-call | TODO
literal-expression ::=(quote
datum)
|’
datum | constant constant ::= number | boolean | character | string
(quote datum)
evaluates to datum,
which may be any external representation of a Scheme object.
This notation is used to include literal constants in Scheme code.
(quote a) ⇒ a (quote #(a b c)) ⇒ #(a b c) (quote (+ 1 2)) ⇒ (+ 1 2)
(quote datum)
may be abbreviated as 'datum
.
The two notations are equivalent in all respects.
’a ⇒ a ’#(a b c) ⇒ #(a b c) ’() ⇒ () ’(+ 1 2) ⇒ (+ 1 2) ’(quote a) ⇒ (quote a) ’’a ⇒ (quote a)
Numerical constants, string constants, character constants, bytevector constants, and boolean constants evaluate to themselves; they need not be quoted.
145932 ⇒ 145932 #t ⇒ #t "abc" ⇒ "abc"
Note that keywords need to be quoted, unlike some other Lisp/Scheme dialect, including Common Lisp, and earlier versions of Kawa. (Kawa currently evaluates a non-quoted keyword as itself, but that will change.)
variable-reference ::= identifier
An expression consisting of a variable is a variable reference if it is not a macro use (see below). The value of the variable reference is the value stored in the location to which the variable is bound. It is a syntax violation to reference an unbound variable.
The following example assumes the base library has been imported:
(define x 28) x ⇒ 28
procedure-call ::=(
operator operand …) operator ::= expression operand ::= expression | keyword expression |@
expression |@:
expression
A procedure call consists of expressions for the procedure to be called and the arguments to be passed to it, with enclosing parentheses. A form in an expression context is a procedure call if operator is not an identifier bound as a syntactic keyword.
When a procedure call is evaluated, the operator and operand expressions are evaluated (in an unspecified order) and the resulting procedure is passed the resulting arguments.
(+ 3 4) ⇒ 7 ((if #f + *) 3 4) ⇒ 12
The syntax keyword expression is a keyword argument. This is a mechanism for specifying arguments using a name rather than position, and is especially useful for procedures with many optional paramaters. Note that keyword must be literal, and cannot be the result from evaluating a non-literal expression. (This is a change from previous versions of Kawa, and is different from Common Lisp and some other Scheme dialects.)
An expression prefixed by @
or @:
is
a splice argument. The following expression must evaluate to an
“argument list” (see Application and Arguments Lists for details);
each element in the argument
becomes a separate argument when call the operator.
(This is very similar to the “spread” operator is EcmaScript 6.)
Next: Property access using colon notation, Previous: Hash-prefixed forms, Up: Syntax [Contents][Index]