Adding an element to List in Scheme

Below is my code which takes a car element of a list(carVal) and an list(initialized to empty) as parameters. I want to append the element to the list but the same is not working.

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

The display shows empty list all the time () . Can anyone help me understand why?


  • Well, there is append! as a primitive, which solves most of your problems, as noted already, Scheme tends to frown on mutation, it is possible, but typically avoided, so all procedures that mutate have a ! (called a bang) at their end.

    Also, set! does not mutate data, it changes an environment, it makes a variable point to another thing, the original data is left unchanged.

    Mutating data in Scheme is quite cumbersome, but, to give you my own implementation of append! to see how it is done:

    (define (append! lst . lsts)
      (if (not (null? lsts))
          (if (null? (cdr lst))
                (set-cdr! lst (car lsts))
                (apply append! (car lsts) (cdr lsts)))
              (apply append! (cdr lst) lsts))))

    Note the use of set-cdr!, which is a true mutator, it only works on pairs, it mutates data in memory, unlike `set!'. If a pair is passed to a function and mutated with set-cdr! or set-car!, it is mutated every-where in the program.

    This obeys the SRFI append! spec which says that it should be variadic and that it should return an undefined value, for instance.

    (define l1 (list 1 2 3 4))
    (define l2 (list 2 3 4))
    (define l3 (list 3 1))
    (append! l1 l2 l3)

    Which displays:

    (1 2 3 4 2 3 4 3 1)
    (2 3 4 3 1)
    (3 1)

    As visible, append! can take an infinite number of arguments and it mutates them all but the last.

    Scheme might not be the ideal language for you though. The use of append! as said before is nonstandard, instead, append is preferred, which does not mutate and is called for its return value. Which I implement as such:

    (define (append . lsts)
        ((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 'reasonable 'behavior))
    (1 2 3 4 5 6 reasonable behavior)

    Which shows a more familiar Scheme style in the absence of mutation, heavy use of recursion and no use of sequencing.

    Edit: If you just want to add some elements to a list and not per se join two though:

    (define (extend l . xs)
      (if (null? l) 
          (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)

    Which does what you expect