How to update a list in Scheme (Racket)

Question

How do you send a list to a separate function/procedure, delete an item from the list, update the new list (item removed), and display it from the first function/procedure.

Also, I know you can use set! to update the list, but I keep seeing manuals that say that using set! is not the "Scheme way".

But, I don't understand how else to create this program besides this way (which doesn't work):

#lang racket

(define list1 '("read" "id" "$$"))

(define (displayer list1)
  (remover list1)
  (newline)
  (display list1)) ;also doesn't display updated list here

(define (remover list1)
  (remove "$$" list1)
  (display list1))  ;doesn't display updated list here

Thanks!

Answer 1

As stated in the question, this is really, really not the way to do things in Scheme; nevertheless you can achieve what you ask in Racket by set!-ing a global definition and choosing a language that allows the redefinition of initial bindings - the fact that you have to mess around with language settings should be a pretty clear sign that you're Doing It Wrong.

Anyway, here's how:

(define list1 '("read" "id" "$$"))

(define (displayer)
  (remover)
  (newline)
  (display list1))

(define (remover)
  (set! list1 (remove "$$" list1))
  (display list1))

(displayer)
> (read id)
> (read id)

A more idiomatic approach would be to avoid defining global variables for modifying them inside procedures; instead every time you need to modify a list create a new one (remove creates a new list) and pass it around, like this:

(define (displayer lst)
  (let ((removed (remover lst)))
    (newline)
    (display removed)))

(define (remover lst)
  (let ((removed (remove "$$" lst)))
    (display removed)
    removed))

(define list1 '("read" "id" "$$"))
(displayer list1)
> (read id)
> (read id)

Notice that the second solution does not modify list1, that's the functional way to solve the problem.

Answer 2

With your code if I write:

(displayer list1)

it will display:

(read id $$)

But if I change it to:

#lang racket

(define list1 '("read" "id" "$$"))

(define (displayer list1)
   (display (remover list1))) 

(define (remover list1)
  (remove "$$" list1)) 

This way when you run

(displayer list1)

It will return

(read id)

remember that in functional languages, everything is an expression and dealing with "variables" as not mutable is the preferred way (working without state makes it easier to verify, optimize, and parallelize programs, and easier to write automated tools to perform those tasks, read more here: http://en.wikipedia.org/wiki/Functional_programming#Comparison_to_imperative_programming ) , so if you want to remove an element from a list and then display you have to write a function that returns a new list with less elements

On the other hand, Racket is not a pure functional language like Haskell, so as you mentioned, if you really want to redefine the value referenced by the variable "list1" you can use Racket in a imperative way like this:

#lang racket
(define list1 '("read" "id" "$$"))

(define (displayer list1)
  (set! list1 (remover list1))
  (newline)
  (display list1)) 

(define (remover list1)
  (remove "$$" list1))  

The set! redirects the list1 to point to the new value from now on

You can read more about this here: http://htdp.org/2003-09-26/Book/curriculum-Z-H-44.html

Answer 3

(remove "$$" list1)

returns list1 with the "$$" removed, but does not change list1. So the solution is to call display with the remover call:

(display (remover list1))

and to reimplement remover to remove the "$$", but have no other side-effects (output is a side-effect):

(define (remover list1) (remove "$$" list1))