What is the difference between map and apply in scheme?

by

They are not the same! Their names can actually help remember which does what.

map will take as argument one procedure and one or more lists. The procedure will be called once for each position of the lists, using as arguments the list of elements at that position:

(map - '(2 3 4))
; => (-2 -3 -4)

map called (- 2), (- 3), (- 4) to build the list.

(map + '( 1  2  3)
       '(10 20 30))
; => (11 22 33)

map called (+ 1 10) (+ 2 20) (+ 3 30) to build the list.

(map * '(2 2 -1)
       '(0 3  4)
       '(5 4  2))
; => (0 24 -8)

map called (* 2 0 5) (* 2 3 4) (* -1 4 2) to build the list.

map has that name because it implements a “map” (function) on a set of values (in the lists):

(map - '(2 3 4))
 arguments     mapping "-"     result
     2       === (- 2) ===>     -2
     3       === (- 3) ===>     -3
     4       === (- 4) ===>     -4

(map + '( 1  2  3)
       '(10 20 30))
 arguments      mapping "+"      result
    1 10     === (+ 1 10) ===>     11 
    2 20     === (+ 2 20) ===>     22
    3 30     === (+ 3 30) ===>     33

apply will take at least two arguments, the first of them being a procedure and the last a list. It will call the procedure with the following arguments, including those inside the list:

(apply + '(2 3 4))
; => 9

This is the same as (+ 2 3 4)

(apply display '("Hello, world!"))
; does not return a value, but prints "Hello, world!"

This is the same as (display "Hello, world!").

apply is useful when you have arguments as a list,

(define arguments '(10 50 100))
(apply + arguments)

If you try to rewrite the last line without using apply, you’ll realize that you need to loop over the list summing each element…

apply may also be used with more than those two arguments. The first argument must be a callable object (a procedure or a continuation). The last one must be a list. The others (between the first and the last) are objects of any type. So calling

(apply PROC a b c ... y z '(one two ... twenty))

is the same as calling

(PROC a b c ... y z  one two ... twenty)

Here’s a concrete example:

(apply + 1 -2 3 '(10 20))
; => 32

This is the same as (+ 1 -2 3 10 20)

apply has that name because it allows you to “apply” a procedure to several arguments.

Leave a Comment