(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

  • eq? tests whether two objects are the same (pointer equality).
  • eqv? extends eq? by treating numbers and characters with the same value as equivalent.
  • equal? performs deep structural comparison, suitable for lists, vectors, strings, etc.

• eval returns objects

  • (eval expr module) evaluates an expression and returns the resulting Scheme object, not its printed form.

• exact->inexact: floats are inexact, integers are exact

  • Exact numbers include integers and rational numbers.
  • Inexact numbers include floating-point values.
  • (exact->inexact 3) yields 3.0; the reverse is possible with (inexact->exact).

• file tree walk

  • Use (scandir path predicate) to list directory entries.
  • Use (file-is-directory? file) to detect subdirectories.
  • Combine recursively to walk the file tree.

• map with multiple arguments

  • (map proc lst1 lst2 ...) applies proc to elements taken simultaneously from each list.
  • Evaluation stops when the shortest list is exhausted.

• multiple hash-table interfaces, multiple exception interfaces

  • Guile supports native hash tables and SRFI-69.
  • It offers multiple exception systems: legacy (catch), SRFI-34, and SRFI-18.
  • Interfaces may differ in API and behavior.

• named let defines and calls a procedure

  • A named let defines a recursive procedure and invokes it immediately.
  • Useful for stateful or tail-recursive loops without top-level define.

• pattern matching with (ice-9 match)

  • (use-modules (ice-9 match)) enables match expressions.
  • Supports destructuring, nested patterns, and guards for concise branching.

• sandbox evaluation

  • Sandboxing can be achieved by limiting the bindings in the evaluation environment.
  • Control I/O and resource access externally for isolation.

• the guile c interface

  • Guile's libguile provides a C API to embed Scheme or expose C functions to Scheme.
  • Use scm_c_define_gsubr, scm_from_int, etc., for interoperation.

• the use of begin on the toplevel

  • begin sequences expressions but does not introduce a new scope at the top level.
  • All side effects are executed in order during loading.

• uniform vectors and c

  • Uniform vectors (u8vector, f64vector, etc.) store homogenous, fixed-type data.
  • They map directly to C-compatible arrays for efficient interop.

• the identity function

  • (define (identity x) x) is the canonical form.
  • Also expressed as values in multiple-value contexts.

• guile procedure index

  • Guile provides a comprehensive index of procedures in its manual.
  • Accessible via info guile or online, useful for API discovery.

• continuation passing style

  • Guile supports CPS through first-class continuations and call/cc.
  • Enables non-local exits, backtracking, and coroutines.

• lists are chains of pairs

  • Scheme lists are built from nested pairs (cons cells).
  • Each node’s car holds a value; cdr points to the next pair or ().