1.1.6 Scheme procedures

Scheme procedures are executable scheme expressions that return a value resulting from their execution. They can also manipulate variables defined outside of the procedure.

Defining procedures

Procedures are defined in Scheme with define

(define (function-name arg1 arg2 ... argn)

For example, we could define a procedure to calculate the average:

guile> (define (average x y) (/ (+ x y) 2))
guile> average
#<procedure average (x y)>

Once a procedure is defined, it is called by putting the procedure name and the arguments in a list. For example, we can calculate the average of 3 and 12:

guile> (average 3 12)


Scheme procedures that return boolean values are often called predicates. By convention (but not necessity), predicate names typically end in a question mark:

guile> (define (less-than-ten? x) (< x 10))
guile> (less-than-ten? 9)
guile> (less-than-ten? 15)

Return values

Scheme procedures always return a return value, which is the value of the last expression executed in the procedure. The return value can be any valid Scheme value, including a complex data structure or a procedure.

Sometimes the user would like to have multiple Scheme expressions in a procedure. There are two ways that multiple expressions can be combined. The first is the begin procedure, which allows multiple expressions to be evaluated, and returns the value of the last expression.

guile> (begin (+ 1 2) (- 5 8) (* 2 2))

The second way to combine multiple expressions is in a let block. In a let block, a series of bindings are created, and then a sequence of expressions that can include those bindings is evaluated. The return value of the let block is the return value of the last statement in the let block:

guile> (let ((x 2) (y 3) (z 4)) (display (+ x y)) (display (- z 4))
… (+ (* x y) (/ z x)))

LilyPond — Extending v2.24.3 (stable-branch).