chickadee » chicken » read-syntax

Non-standard read syntax

Escapes in symbols

| ... | may be used to escape a sequence of characters when reading a symbol. \X escapes a single character in a symbols name:

 (symbol->string '|abc def|)       =>   "abc def"
 (symbol->string '|abc||def|)      =>   "abcdef"
 (symbol->string '|abc|xyz|def|)   =>   "abcxyzdef"
 (symbol->string '|abc\|def|)      =>   "abc|def"
 (symbol->string 'abc\ def)        =>   "abc def"

Multiline Block Comment

#| ... |# 

A multiline block comment. May be nested. Implements SRFI-30.

Expression Comment


Treats EXPRESSION as a comment. That is, the comment runs through the whole S-expression, regardless of newlines, which saves you from having to comment out every line, or add a newline in the middle of your parens to make the commenting of the last line work, or other things like that. Implements SRFI-62.

External Representation


Allows user-defined extension of external representations. (For more information see the documentation for SRFI-10)

Location Expression


An abbreviation for (location EXPRESSION).

Blob literals

 #${ HEX ... }

Syntax for literal "blobs" (byte-sequences). Expects hexadecimal digits and ignores any whitespace characters:

 #;1> ,d '#${deadbee f}
 blob of size 4:
    0: de ad be ef                                     ....



Syntax for keywords. Keywords are symbols that evaluate to themselves, and as such don't have to be quoted. Either SYMBOL: or :SYMBOL is accepted, depending on the setting of the keyword-style parameter, but never both. #:SYMBOL is always accepted.

Multiline String Constant


Specifies a multiline string constant. Anything up to a line equal to TAG (or end of file) will be returned as a single string:

(define msg #<<END
 "Hello, world!", she said.

is equivalent to

(define msg "\"Hello, world!\", she said.")

Multiline String Constant with Embedded Expressions


Similar to #<<, but allows substitution of embedded Scheme expressions prefixed with # and optionally enclosed in curly brackets. Two consecutive #s are translated to a single #:

(define three 3)
(display #<#EOF
This is a simple string with an embedded `##' character
and substituted expressions: (+ three 99) ==> #(+ three 99)
(three is "#{three}")


This is a simple string with an embedded `#' character
and substituted expressions: (+ three 99) ==> 102
(three is "3")

Foreign Declare

#> ... <#

Abbreviation for (foreign-declare " ... ").

String escape sequences

String-literals may contain the following escape sequences:

Escape sequenceCharacter
\nline feed / newline
\rcarriage return
\vvertical tab
\fform feed
\xXXhexadecimal 8-bit character code
\uXXXXhexadecimal 16-bit Unicode character code
\UXXXXXXXXhexadecimal 32-bit Unicode character code
\OOOoctal 8-bit character code
\|   \"    \\    \'the escaped character

Sharp Prefixed Symbol


Reads like a normal symbol.



Interpretation depends on the directly following characters. Only the following are recognized. Any other case results in a read error.

Line Comment
If followed by whitespace or a slash, then everything up the end of the current line is ignored
Eof Object
If followed by the character sequence eof, then the (self-evaluating) end-of-file object is returned
DSSSL Formal Parameter List Annotation
If followed by any of the character sequences optional, rest or key, then a symbol with the same name (and prefixed with #!) is returned
Read Mark Invocation
If a read mark with the same name as the token is registered, then its procedure is called and the result of the read-mark procedure will be returned

Case Sensitive Expression


Read the next expression in case-sensitive mode (regardless of the current global setting).

Case Insensitive Expression


Read the next expression in case-insensitive mode (regardless of the current global setting).

Conditional Expansion


Rewrites to

(cond-expand (FEATURE EXPR) (else))

and performs the feature test at macroexpansion time. Therefore, it may not work as expected when used within a macro form.

Previous: Extensions to the standard

Next: Non-standard macros and special forms

Contents »