lambda pattern matching

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

-> a:1 b:2 c:3

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

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

  (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

  (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

  (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

iteration, loops and recursion

  • 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 customised and extended