### 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)
scheme-expression-that-gives-a-return-value)
```

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

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

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) 15/2 ```

#### Predicates

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) #t guile> (less-than-ten? 15) #f ```

#### 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)) 4 ```

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))) 508 ```