(r5rs.info.gz) Symbols
Info Catalog
(r5rs.info.gz) Pairs and lists
(r5rs.info.gz) Other data types
(r5rs.info.gz) Characters
6.3.3 Symbols
-------------
Symbols are objects whose usefulness rests on the fact that two symbols
are identical (in the sense of `eqv?') if and only if their names are
spelled the same way. This is exactly the property needed to represent
identifiers in programs, and so most implementations of Scheme use them
internally for that purpose. Symbols are useful for many other
applications; for instance, they may be used the way enumerated values
are used in Pascal.
The rules for writing a symbol are exactly the same as the rules for
writing an identifier; see sections Identifiers and
Lexical structure.
It is guaranteed that any symbol that has been returned as part of a
literal expression, or read using the `read' procedure, and
subsequently written out using the `write' procedure, will read back in
as the identical symbol (in the sense of `eqv?'). The `string->symbol'
procedure, however, can create symbols for which this write/read
invariance may not hold because their names contain special characters
or letters in the non-standard case.
_Note:_ Some implementations of Scheme have a feature known as
"slashification" in order to guarantee write/read invariance for
all symbols, but historically the most important use of this
feature has been to compensate for the lack of a string data type.
Some implementations also have "uninterned symbols", which defeat
write/read invariance even in implementations with slashification,
and also generate exceptions to the rule that two symbols are the
same if and only if their names are spelled the same.
-- procedure: symbol? obj
Returns #t if OBJ is a symbol, otherwise returns #f.
(symbol? 'foo) ==> #t
(symbol? (car '(a b))) ==> #t
(symbol? "bar") ==> #f
(symbol? 'nil) ==> #t
(symbol? '()) ==> #f
(symbol? #f) ==> #f
-- procedure: symbol->string symbol
Returns the name of SYMBOL as a string. If the symbol was part of
an object returned as the value of a literal expression (section
Literal expressions) or by a call to the `read' procedure,
and its name contains alphabetic characters, then the string
returned will contain characters in the implementation's preferred
standard case--some implementations will prefer upper case, others
lower case. If the symbol was returned by `string->symbol', the
case of characters in the string returned will be the same as the
case in the string that was passed to `string->symbol'. It is an
error to apply mutation procedures like `string-set!' to strings
returned by this procedure.
The following examples assume that the implementation's standard
case is lower case:
(symbol->string 'flying-fish)
==> "flying-fish"
(symbol->string 'Martin) ==> "martin"
(symbol->string
(string->symbol "Malvina"))
==> "Malvina"
-- procedure: string->symbol string
Returns the symbol whose name is STRING. This procedure can
create symbols with names containing special characters or letters
in the non-standard case, but it is usually a bad idea to create
such symbols because in some implementations of Scheme they cannot
be read as themselves. See `symbol->string'.
The following examples assume that the implementation's standard
case is lower case:
(eq? 'mISSISSIppi 'mississippi)
==> #t
(string->symbol "mISSISSIppi")
==>
the symbol with name "mISSISSIppi"
(eq? 'bitBlt (string->symbol "bitBlt"))
==> #f
(eq? 'JollyWog
(string->symbol
(symbol->string 'JollyWog)))
==> #t
(string=? "K. Harper, M.D."
(symbol->string
(string->symbol "K. Harper, M.D.")))
==> #t
Info Catalog
(r5rs.info.gz) Pairs and lists
(r5rs.info.gz) Other data types
(r5rs.info.gz) Characters
automatically generated byinfo2html