Syntax at a Glance

(list 42 #t "tea" #\T 'ready)
; the comment is ignored

(42 #t "tea" #\T ready)

Numbers, booleans, strings, and characters can be written directly. The quote in 'ready makes ready a symbol value. A semicolon starts a comment that continues to the end of the line.

(+ 10 (* 2 3))

16

The inner call (* 2 3) returns 6, so the outer call adds 10 and 6. In a procedure call, the first expression selects the procedure. That expression and the arguments are evaluated from left to right.

(let ((trim-width 20) (bleed 3))
  (+ trim-width bleed))

23

let gives local names to values. Here, trim-width is 20 and bleed is 3. The initial value expressions use the surrounding scope, so neither can use the other's new name. Use define for a top-level name. Use let* when a later local value needs an earlier name, and letrec for recursive local definitions.

(define (double n) (* n 2))
(double 6)

12

define names a procedure and its arguments. Here, double multiplies its argument by 2. A procedure is itself a value. You can create one without naming it by using lambda.

(if (< 1 2) 'next-page 'keep)

next-page

if selects 'next-page because one remaining line is less than two. cond checks several conditions in order. case selects by matching a value. and and or stop when the result is known. Only #f counts as false.

(list 'decision 'allow)

(decision allow)

A quote keeps data from being evaluated. Here, 'decision and 'allow are symbol values. list evaluates its arguments and puts their values into a new list.

(list (string-length "Lispex")
      (vector-ref #(red green blue) 1))

(6 green)

string-length counts the characters in "Lispex". vector-ref selects an element by an index starting at zero, so index 1 selects green. Strings hold Unicode text. Vectors hold ordered elements and can be changed in the current language profile. Bytevectors hold values from 0 through 255 and cannot be changed.

(map (lambda (n) (* n 10)) '(1 2 3))

(10 20 30)

map calls the procedure for each list element and returns the results in a list. filter selects elements, and folds combine them into an accumulated value. apply calls a procedure with arguments from a list. A recursive procedure calls itself. Tail calls let repeated recursive calls run without growing the call stack.