Utilisation de la voiture et cdr

Question

Je suis nouveau sur le schéma et avoir du mal à utiliser la voiture et cdr. J'ai une chaîne littérale AST dans ast.

(define ast '(program 
    ((assign (var i int) (call (func getint void int)())) 
    (assign (var j int) (call (func getint void int)())) 
    (while (neq (var i int) (var j int)) 
    ((if (gt (var i int) (var j int)) 
     ((assign (var i int) (minus (var i int) (var j int)))) 
     ((assign (var j int) (minus (var j int) (var i int))))))) 
    (call (func putint int void) ((var i int))))) 
) 

Je sais que la voiture retourne la tête de ast. Donc

(car ast) 

retourne le programme.

Je suis confus comment utiliser car et cdr pour obtenir des chaînes de ast comme 'assigner', tandis que, 'si, et' appel.

Answer 1

Vous devez undertstand comment les paires et les listes sont construites, à partir The Racket Reference:

Une paire combine exactement deux valeurs. La première valeur est accédée avec la procédure de voiture, et la deuxième valeur est accédée avec la procédure cdr. Les paires ne sont pas mutables (mais voir Paires mutables et listes).

Une liste est définie de manière récursive: elle est soit la constante nulle, soit une paire dont la deuxième valeur est une liste.

En gros - chaque paire est deux - (. X y) voiture nous obtient x cdr nous amène y

Notez que x et y peuvent tous deux être deux ou listes elles-mêmes, tout comme votre ast.

par exemple: (de même référence)

> (define lst1 (list 1 2 3 4)) 

>lst1 

'(1 2 3 4) 

avis que « (1 2 3 4) est en fait:.... (1 (2 (3 (4()))) < . - très important de connaître la mise en œuvre dans le schéma

> (car lst1) 

1 

> (cdr lst1) 

'(2 3 4) 

> (car (cdr lst1)) 

2 

une autre façon de voiture de la chaîne et les appels cdr (lire à droite): moyens CADR (cdr LST) puis la voiture sur la réponse = (voiture (cdr lst))

> (cdddr lst1) 

'(4) 

> (cadddr lst1) 

4 

> (define lst2 (list (list 1 2) (list 3 4))) 

>lst2 

'((1 2) (3 4)) 

= ((1. (2.())). (3. (4.())))

> (car lst2) 

'(1 2) 

>(cdr lst2) 

'((3 4)) 

qui est en fait ((3. (4.())).()) = ((3 4).()) = ((3 4)) Vous n'avez pas demandé mais, je suppose que vous allez traverser l'arbre/la liste. En fin de compte, vous devrez traverser un recurssion (à moins d'utiliser la méthode avancée ne convient pas à ce stade, à savoir vérifier CPS lorsque vous êtes prêt) comme ceci:

(define runner 
    (lambda (tree) 
    (if (null? tree) 
     null 
     (let ((first_element (car tree)) 
       (rest_of_tree (cdr tree))) 
      ;body: 
      ;do some logic like: 
       ;if first is list call runner on it 
       ;else check what string is there (recognize tree root) 
      ;call (runner rest_of_tree) 
      ;possibly chain answer of logic and call together 
     )))) 

Hope this helps les questions sont les bienvenus.