We can use combinations of the datatypes and primitive procedures to perform simple (and not so simple) calculations using the scm interpreter:

```
> (+ 2 2)
4
> (* 2 8)
16
> (- 2 1)
1
> (/ 3 4)
0.75
```

These are, in order,

- Addition
- Multiplication
- Subtraction
- Division

Each of these expressions can be nested within one another, thus:

```
> (+ (* 2 4) (/ 3 4) (- 2 1) (+ 2 2))
13.75
```

This shows 2 important things about Scheme expressions:

- Scheme expressions can be nested, leading to an important concept, the Substitution Model.
- Some procedures can take a variable number of arguments; we'll show how to do this later.

The first point is most important at this point.

#### The Substitution ModelEdit

The substitution model for computing expressions is one of the simplest and most powerful ways of thinking about Scheme expressions. It can be regarded as the basis of a large portion of Scheme.

In order to understand the substitution model, I'll give you a simple example, the one given before, and work through it.

```
> (+ (* 2 4) (/ 3 4) (- 2 1) (+ 2 2))
```

In order to evaluate this, the scheme interpreter must evaluate every sub-expression, thus decomposing it to atomic datatypes and primitives:

```
> (+ 8 0.75 1 4)
13.75
```

This same model can be applied to extra layers of nesting.

```
> (* (+ 13 1) (+ (* 2 4) (/ 3 4) (- 2 1) (+ 2 2)))
> (* (+ 13 1) (+ 8 0.75 1 4))
> (* 14 13.75)
192.5
```

The best way to think about this is as a basic algorithm.

- Has the expression any subexpressions?
- yes: Evaluate subexpressions using this algorithm
- no: Evaluate whole expression of primitives.