(apply
  (lambda (a b c) #t)
  (list 1 2 3))

-> a:1 b:2 c:3

(apply
  (lambda (a b . c) #t)
  (list 1 2 3 4 5))

-> a:1 b:2 c:(3 4 5)

(apply
  (lambda* (a #:optional b) #t)
  (list 1 2))

-> a:1 b:2. if a shorter list (list 1) where given instead, then a:1 b:#f

(apply
  (lambda* (a #:key (b 8) c) #t)
  (list 1 #:b 2 #:c 3))

the special #: keyword syntax of lambda* is used to differentiate from normal symbols.

unfortunately, the following does not work

(apply
  (lambda (a . b) #t)
  (pair 1 2))

• eq, eqv, equal
• eval returns objects
• exact->inexact: floats are inexact, integers are exact
• file tree walk
• map with multiple arguments
• multiple hash-table interfaces, multiple exception interfaces
• named let defines and calls a procedure
• pattern matching with (ice-9 match)
• sandbox evaluation
• the guile c interface
• the use of begin on the toplevel
• uniform vectors and c
• the identity function
• guile procedure index
• continuation passing style
• lists are chains of pairs

• folding and mapping. unfold, pair-fold, parallel map

• the stop condition

  • recursion needs a condition for which it stops or it continues indefinitely
  • when working with loops, decide and look for the stop condition

• map, fold and unfold only create one result - how to change multiple values which each iteration

  • custom loops

  • fold and an updated nested data structure

  • mutating variables is possible in scheme (set!), but in a purely functional language the values of bindings are declared at specific points (lambda arguments) as dependencies for scopes in which they are bound

understand this loop:

(let loop ((rest (list 1 2 3)))
  (if (null? rest) rest
    (cons (+ 1 (car rest)) (loop (cdr rest)))))

it maps a list and, compared to the map procedure, can be customized and extended