6.8.16.1 Notes on the supported syntax

Some expression syntax interpretation rules:

• Any Scheme value can be element of the input form; numbers and all the other values are just put there as operands.

  #!vicare
  (infix list("ciao", 'hello, '#ve(ascii "salut")))
  ⇒ ("ciao" hello #ve(ascii "salut"))
  

• The following bound identifiers exported by (vicare) are interpreted as binary infix operators:

  + - * / div div0 mod mod0 expt
  fl+ fl- fl* fl/ flexpt
  fx+ fx- fx* fxdiv fxdiv0 fxmod fxmod0
  < > <= >= = !=
  fx<? fx>? fx<=? fx>=? fx=?
  fl<? fl>? fl<=? fl>=? fl=?
  eq? eqv? equal?
  and or xor
  bitwise-and bitwise-ior bitwise-xor
  bitwise-arithmetic-shift-left
  bitwise-arithmetic-shift-right
  fxand fxior fxxor
  fxarithmetic-shift-left
  fxarithmetic-shift-right
  

  in addition the following identifiers are recognised by their symbol name and interpreted as aliases of binary infix operators:

  &&              → and
  \x23D0;\x23D0;  → or
  \x00AC;         → not
  \x2227;         → and
  \x2228;         → or
  \x22BB;         → xor
  ==              → =
  <>              → !=
  \x00D7;         → *
  \x22C5;         → *
  **              → expt
  %               → mod
  &               → bitwise-and
  \x23D0;         → bitwise-ior
  ^               → bitwise-xor
  <<              → bitwise-arithmetic-shift-left
  >>              → bitwise-arithmetic-shift-right
  

  where the symbols with escape sequences are:

  ‘\x00AC;’

  Unicode character not sign.

  ‘\x00D7;’

  Unicode character times.

  ‘\x2227;’

  Unicode character logical and.

  ‘\x2228;’

  Unicode character logical or.

  ‘\x22BB;’

  Unicode character xor.

  ‘\x22C5;’

  Unicode character dot operator.

  ‘\x23D0;’

  Unicode character vertical bar extension.

• The following bound identifiers exported by (vicare) are interpreted as unary prefix operators:

  + - ++ --
  fx+ fx- fl+ fl-
  not bitwise-not fxnot
  

  in addition the following identifiers are recognised by their symbol name and interpreted as aliases of unary prefix operators:

  !       → not
  ~       → bitwise-not
  

• The following bound identifiers exported by (vicare) are interpreted as unary postfix operators:

  ++ --
  

  in addition the following identifiers are recognised by their symbol name and interpreted as aliases of unary postfix operators:

  !       → factorial
  

• Almost all the binary infix operators are left–associative with the exception of expt and flexpt which are right–associative:

  ;; left-associative
  (infix 10 - 5 - 3)              → (- (- 10 5) 3)
  (infix 10 - 5 - 3)              → (- 10 5 3)
  (infix 10 / 5 / 3)              → (/ (/ 10 5) 3)
  (infix 10 / 5 / 3)              → (/ 10 5 3)
  
  ;; right-associative
  (infix 10 expt 5 expt 3)        → (expt 10 (expt 5 3))
  

• The identifiers ++ and -- are unary operators that can be applied to expressions both in prefix and postfix positions. They expand as follows:

  #!vicare
  (infix ++ X)            → (pre-incr! X)
  (infix -- X)            → (pre-decr! X)
  (infix X ++)            → (post-incr! X)
  (infix X --)            → (post-decr! X)
  

  where pre-incr!, pre-decr!, post-incr! and post-decr! are the bindings exported by (vicare).

• The ternary conditional operator involves the identifiers ? and :, which are recognised by their symbol name.

  (infix 1 > 2 ? 3 + 4 : 5 * 6)
  → (if (> 1 2) (+ 3 4) (* 5 6))
  

• Identifiers which are not operators are interpreted as variable references.
• If an identifier is followed by a left parenthesis: it is interpreted as the binding of a procedure in a procedure application. Procedure application requires the arguments to be grouped in a list, using the comma as separator.

  (define (fun a b c)
    (+ a b c))
  
  (infix fun (1, 2, 3))   → (fun 1 2 3)
  

  NOTE The Scheme reader transforms the sequence:

  , ?form
  

  into:

  (unsyntax ?form)
  

  so the list of arguments is:

  ( ?arg1 (unsyntax ?arg) ... )
  

  R6RS does not define the comma to be a delimiter, so writing:

  func (?arg1, ?arg, ...)
  

  with no space between the ?arg and the comma is a syntax error in strict R6RS implementations. Vicare extends the reader to handle the comma as a delimiter, so the above expression is valid in the infix syntax.

• The identifiers quote, quasiquote, syntax and quasisyntax are not subject to infix to prefix conversion; the use of such syntaxes just expands to the prefix object:

  (infix (quote       ciao))  → (quote ciao)
  (infix (quasiquote  ciao))  → (quasiquote ciao)
  (infix (syntax      ciao))  → (syntax ciao)
  (infix (quasisyntax ciao))  → (quasisyntax ciao)
  

• Matched left and right round parentheses are used to group subexpressions, overriding operators precedence rules.