The syntax gets parsed and for a Scheme reader '(1 . (2 . ()))
gets parsed and creates the same structure as '(1 2)
. Basically proper lists are singly linked lists where the last cdr
points to the empty list.
(somefun . (5))
is the same as (somefun 5)
for the reader. When the source code is turned in to a data structure, the interpreter won't know if you wrote the one or the other. Hovever (somefun . 5)
doesn't get parsed to a function with one argument since the argument list itself is a number. the parser parsed it into a data structure, but your scheme implementation responsible to compile it or interpret it failed. You may use dotted list in data and some syntax like lambda
for rest arguments, but it is very limited. Most of the time using dotted pairs in code fails.
A Scheme system will display structure only one way. eg. if you put in '(1 . (2 . ()))
you will se (1 2)
back since a dot with a list or empty list cdr
gets special list visualization. If you do '(1 . (2 . 3))
it can start using the special rule since the cdr
is a pair, but the next won't fly ending it up as (1 2 . 3)
. If you evaluate '(equal? . ((quote . ((a . (b . (c . ()))))) . ('(a b c))))
you get (equal? '(a b c) '(a b c))
back and that is because it is the simplest visualization of that structure. As code they read to the same structure and evaluate the same.
The most common problem when learning Scheme is to understand the list structure. Eg. how to create ((1 2) (3 4))
using cons
and how to access the 4
. If you knew it is really ((1 . (2 . ()) . ((3 . (4 . ()))))
you see the 4 is after fllowing the cdr
, car
, cdr
, then car
or the simplified (cadadr '((1 2) (3 4)))
. The visualizer will just omit the dot and the extra set of parentheses in the cdr
if it has them. eg. '((a) . (b))
will become ((a) b)
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…