L'ajout d'un élément de Liste dans le Schéma

Ci-dessous mon code qui prend une voiture élément d'une liste(carVal) et une liste(vide) en tant que paramètres. Je tiens à ajouter l'élément à la liste, mais ce n'est pas le travail.

(define populateValues
   (lambda (carVal currVal)
      (append currVal(list carVal ))
       (display currVal)))

L'écran affiche la liste vide tout le temps () . Quelqu'un peut-il m'aider à comprendre pourquoi?

OriginalL'auteur name_masked | 2010-07-03

24

Bien, il n'y a append! comme un primitif, ce qui résout la plupart de vos problèmes, comme déjà mentionné, le Régime a tendance à froncer les sourcils sur la mutation, c'est possible, mais généralement évités, de sorte que toutes les procédures de mutation ont un ! (appelé bang) à leur fin.

Aussi, set! ne pas muter données, il change un environnement, il fait un point variable à une autre chose, les données d'origine reste inchangé.

La mutation de données dans le Schéma est assez lourd, mais, pour vous donner ma propre mise en œuvre de l'ajouter! pour voir comment c'est fait:
```
(define (append! lst . lsts)
  (if (not (null? lsts))
      (if (null? (cdr lst))
          (begin
            (set-cdr! lst (car lsts))
            (apply append! (car lsts) (cdr lsts)))

          (apply append! (cdr lst) lsts))))
```
Notez l'utilisation de set-cdr!, qui est un vrai mutateur, il ne fonctionne que sur les paires, il transforme les données en mémoire, à la différence de`!'. Si une paire est passé à une fonction et muté avec un set-cdr! ou set-car!, il est muté à chaque où dans le programme.

Ce qui obéit à la DDRS ajouter! spec qui dit qu'il devrait être variadic et qu'il doit retourner une valeur non définie, par exemple.
```
(define l1 (list 1 2 3 4))

(define l2 (list 2 3 4))

(define l3 (list 3 1))

(append! l1 l2 l3)

l1

l2

l3
```
Qui s'affiche:
```
(1 2 3 4 2 3 4 3 1)
(2 3 4 3 1)
(3 1)
```
Visible, append! peut prendre un nombre infini d'arguments et il mute tous, mais le dernier.

Régime pourrait ne pas être l'idéal de la langue pour vous si. L'utilisation de l'ajouter! comme dit auparavant, c'est non standard, au lieu de cela, ajouter est préféré, qui n'a pas muté et est appelé pour sa valeur de retour. Qui-je mettre en œuvre en tant que telle:
```
(define (append . lsts)
  (cond
    ((null? lsts) '())
    ((null? (car lsts)) (apply append (cdr lsts)))
    (else (cons (caar lsts) (apply append (cdar lsts) (cdr lsts))))))


> (append (list 1 2 3) (list 4 5 6) (list 'granny 'porn))
(1 2 3 4 5 6 granny porn)
```
Qui montre une plus familier Régime de style en l'absence de mutation, la forte utilisation de la récursivité
et aucune utilisation de séquençage.

Edit: Si vous voulez juste ajouter des éléments à une liste qui n'est pas en soi joindre deux si:
```
(define (extend l . xs)
  (if (null? l) 
      xs
      (cons (car l) (apply extend (cdr l) xs))))

(define (extend! l . xs)
  (if (null? (cdr l))
      (set-cdr! l xs)
      (apply extend! (cdr l) xs)))

(extend '(0 1 2 3) 4 5 6)

(define list1 '(0 1 2 3))

(extend! list1 4 5 6)

list1
```
À ce que vous vous attendez à

Merci pour la réponse .. Btw .. granny , porn .. vous pourriez Vous voulez les changer .. d'Autre, vous pourriez descendre voté 🙂
Il ne fait pas la réponse moins "utile" ou "clair", si les gens veulent downvote à cause de ces choses, alors ce site est déjà perdu. En outre, vous avez votre réponse en tout cas. =) D'ailleurs, d'autres personnes peuvent le modifier s'ils le souhaitent.
Upvote pour granny porno

OriginalL'auteur Zorf
5
1. append crée un nouveau liste, il n'est pas en modifier un existant.
2. C'est parce qu'en général, le Schéma (et de la Raquette dans ce cas) est un langage qui préfère le style fonctionnel.
3. Vous pourriez obtenir un peu plus près avec un set! - mais même qui vous décevoir puisqu'il faudra modifier uniquement la liaison locale.
4. Noter que dans la Raquette en particulier, les listes sont immuables, donc il n'y a rien qui peut changer d'une liste.
5. En outre, même si vous pouviez modifier une liste de cette façon, c'est un moyen inefficace pour accumuler de longues listes, puisque vous avez à plusieurs reprises de numériser l'ensemble de la liste.
6. Enfin, si vous avez des problèmes à ce niveau, alors je vous recommande d'aller sur HtDP
J'ai besoin de venir avec cette fonctionnalité. Que suggéreriez-vous dans ce cas?
Vous pouvez utiliser un box, qui est un type d'un pointeur à un (mutable). MAIS je me doute que vous avez vraiment besoin de cette fonctionnalité -- les débutants pensent souvent qu'ils doivent avoir que parce qu'ils sont utilisés à la mutation étant la seule façon de faire les choses.

OriginalL'auteur Eli Barzilay
2

(append foo bar) retourne la concaténation de foo et bar. Il ne change pas, soit foo ou bar.

OriginalL'auteur sepp2k
0

Vous devez mettre à jour la valeur de currVal avec set!. Votre exemple devrait avoir
```
(set! currVal (append currVal (list carVal))
(display currVal)
```
Notez que cela va changer currVal l'intérieur de la fonction, mais n'aura pas d'effet visible de l'extérieur.

OriginalL'auteur keithm
0

Vous avez vraiment besoin de penser à ce que exactement la fonctionnalité que vous recherchez

Si vous souhaitez muter une liste référencée en place, alors vous devez faire l'équivalent d'ajouter! (comme indiqué dans les autres réponses). Mais c'est dangereux, PARCE que vous pouvez avoir d'autres code qui est en comptant sur la liste étant immuable, et si vous allez le faire, votre procédure doit avoir un ! en fin de compte à l'indicateur de danger.

Pas cher un rapprochement pour ce que vous voulez faire, dans un style fonctionnel, est:
```
(define (populateValues carVal currVal)
 (let ((ll (append currVal (list carVal))))
   (display ll)
   ll))
```
Remarque qu'il fait une nouvelle liste, ne les ajouter, affiche le résultat, et RETOURNE la nouvelle liste, en tant que valeur. Ceci est utile pour le débogage technique si vous n'avez pas accès à de la valeur intermédiaire: se lier à une varible, l'affichage ou l'enregistrer, puis le retourner.

OriginalL'auteur Dak

Vous devez vous connecter pour publier un commentaire.