Appending Elements to an Existing List in Scheme

Question

I need some help understanding the syntax on how to append a number into a list, i'm doing this from user input via the console so this elements have to be entered in recursively. So for ever number that is entered, the list must grow for each element (only numbers) added.

Here is the code I am working with, the problem lies in the second conditional. Right now this works but only creates an empty list of each number I put in, so the results would be

 >12
 >202
 >30
 ()()()
 zero input: stopping list


(define (inputlist)
(let ((applist list))
(let ((inpt (read)))
  (cond
  ((= inpt 0)(newline) (display "zero input: stopping list"))
  ;;OLD((number? inpt) (cons inpt applist) (display (applist))(inputlist))
  ((number? inpt) (append (applist)(list inpt)) (display (applist))(inputlist))
  (else 
  display "Not a number")))))

I understand why cons is not doing what I need it to be doing, but is there a similar functionality to appending each read in element to a pre-existing list?

EDIT: I've gotten closer what i've needed to do but still with the same results, i am now appending upon my applist with a list i create via every input, though it is still resulting in as many empty lists as I input.

SECOND EDIT: I've realized why it's printing multiple ()'s is because it's being called off the stack when 0 is entered, so i'm sure it's not working because the appending isn't working as intended, i've displayed the applist on the 0 conditional and it returns one null list.

Answer 1

Note that (cons x xs) where x is an element and xs is a list produces a new list which has x as its first element.

Here is one way to use cons to add an element in the end of a list:

Example: Add 4 to (1 2 3) 1. Reverse the list: (3 2 1) 2. Add 4 to the front: (4 3 2 1) 3. Reverse: (1 2 3 4)

> (reverse (cons 4 (reverse (list 1 2 3)))
(1 2 3 4)

A function that uses this principle:

(define (cons-to-back x xs)
  (reverse (cons x (reverse xs))))

> (cons-to-back 4 (list 1 2 3))
(1 2 3 4)

An alternative is to use append which appends the elements of two lists:

> (append '(1 2 3) '(4 5 6))
(1 2 3 4 5 6)

All we need to do, is to the the element into a list before using append:

> (append '(1 2 3) (list 4))
'(1 2 3 4)

Alternative definition of cons-to-back:

(define (cons-to-back x xs)
  (append xs (list x)))

Answer 2

A simple way to append an element to the end of a list while looping would be to do call append and update the reference to the list afterwards:

(set! applist (append applist (list inpt)))

Notice that you have several misplaced parentheses - in your code some are missing, some are unnecessary. In Scheme () means function application, and you have to be careful where you put those brackets.

Also, be aware that append doesn't modify the initial list, it creates a new one, and if you need to refer to it, you have to store it somewhere (that's why I'm doing a set! above).

There are more serious errors with you logic. The conditions are in the wrong order (you have to test if the input is a number before asking if it's zero), and you forgot to loop if something other than a number is entered. Also, if we pass along the list as a parameter to the loop, we won't have to do an ugly set!. Try this instead, it's closer to what you were aiming for:

(define (inputlist)
  (let loop ((applist '()))
    (let ((inpt (read)))
      (cond ((not (number? inpt))
             (display "not a number")
             (newline)
             (loop applist))
            ((zero? inpt)
             (display "zero input: stopping list"))
            (else
             (let ((new-applist (append applist (list inpt))))
               (display new-applist)
               (newline)
               (loop new-applist)))))))

As mentioned in the comments, bear in mind that appending at the end of a list inside a loop in general is a bad idea. It's ok for learning purposes, but in real-life code, you'd cons at the head of the list and reverse it at the end - this is more efficient.