comportement de la fonction de lecture du schéma

Question

Je ne comprends pas ce système read le comportement de la fonction.

gosh> (null? '())
#t
gosh> (null? (read))
'()
#f
gosh> (define a (read))
'()
a
gosh> a
'()
gosh> (null? a)
#f

Je m'attendais (null? (read)) est #t (vrai) lorsque j'ai entré '() . Non seulement Gauche, mais aussi MIT-Scheme et GNU/Guile se comporte de cette manière.

Answer 1

El read n'évalue pas le texte qui lui est donné, il le traite comme un expression non évaluée et renvoie l'arbre d'expression comme données. Par exemple :

(read)  ;input: (+ 4 5)

Est équivalent à (list '+ 4 5) :

> (read)  ;input: (+ 4 5)
(+ 4 5)
> (list '+ 4 5)
(+ 4 5)
> (equal? (read) (list '+ 4 5))  ;input: (+ 4 5)
#t

À partir de maintenant, j'utiliserai le ;= pour montrer comment l'écrire avec des constructeurs tels que list .

> (read)  ;input: (+ 4 5)
;= (list '+ 4 5)
(+ 4 5)

Maintenant, parce que read renvoie la représentation des données pour l'expression qui lui est donnée, elle "ajoute un niveau de citation". Je veux dire par là que pour écrire une expression équivalente, vous devriez envelopper quote autour d'elle.

> (read)  ;input: (+ 4 5)
;= (list '+ 4 5)
;= '(+ 4 5)
> (read)  ;input: (quote (+ 4 5))
;= (list 'quote (list '+ 4 5))
;= '(quote (+ 4 5))
;= ''(+ 4 5)

Parce que read y write traiter expressions non évaluées le read semble ajouter un niveau de citation, et la fonction write semble supprimer un niveau de citation :

> (write '(+ 4 5))
;output: (+ 4 5)
> (write ''(+ 4 5))
;output: '(+ 4 5)
> (write '''''(+ 4 5))
;output: ''''(+ 4 5)

El read fait le contraire, semblant ajouter un niveau de citation. Cependant, ceci est rendu plus obscur par le fait que le Scheme Repl utilise la fonction write ce qui le "supprime" à nouveau. Cependant, si vous vous concentrez sur le ;= expressions on comprend mieux pourquoi read y write sont opposés :

> (read)  ;input (+ 4 5)                  (no quotes)
;= '(+ 4 5)                               (one quote)
(+ 4 5)                                   (the `write` function removes a quote)
> (read)  ;input '(+ 4 5)                 (one quote)
;= ''(+ 4 5)                              (two quotes)
'(+ 4 5)                                  (the `write` function removes a quote)
> (read)  ;input '''(+ 4 5)               (three quotes)
;= ''''(+ 4 5)                            (four quotes)
'''(+ 4 5)                                (the `write` function removes a quote)

Revenons maintenant à votre exemple :

> (read)  ;input: '()
;= ???
???

Depuis read ajoute une citation pour représenter une expression en tant que donnée, en lisant '() est équivalent à ''() .

> (read)  ;input: '()
;= ''()
;= (list 'quote (list))
'()
> (define a (read))  ;input: '()
> a
;= ''()
;= (list 'quote (list))
'()
> (equal? a ''())
#t
> (equal? a (list 'quote (list)))
#t

Pour obtenir quelque chose d'équivalent à '() afin qu'il soit null? vous devez donner () comme entrée.

> (read)  ;input: ()
;= '()
;= (list)
()
> (define a (read))  ;input: ()
> a
;= '()
;= (list)
()
> (equal? a '())
#t
> (null? a)
#t