# Arithmetic

So far all we've been able to do is create and name objects. Some of those objects have been numbers — naturally we would like to do calculations with those numbers.

In the last chapter we saw how to create built-in functions to tell `eval_expr` how to process arguments into a return value. We will now create four more builtins to perform the basic arithmetic operations.

ExpressionResult
`(+ X Y)` The sum of `X` and `Y`
`(- X Y)` The difference of `X` and `Y`
`(* X Y)` The product of `X` and `Y`
`(/ X Y)` The quotient of `X` and `Y`

In the definitions above, when we write "the sum of `X` and `Y`", what we really mean is "the sum of the values obtained by evaluating `X` and `Y`". Remember that `eval_expr` will evaluate all the arguments to a functions by default; this is usually what we want to happen, so from now on we will not explicitly state this where the intent is obvious.

#### Implementation

Once again almost all of our function consists of checking that the correct arguments were supplied. Finally the result is constructed by the call to `make_int`.

```int builtin_add(Atom args, Atom *result)
{
Atom a, b;

if (nilp(args) || nilp(cdr(args)) || !nilp(cdr(cdr(args))))
return Error_Args;

a = car(args);
b = car(cdr(args));

if (a.type != AtomType_Integer || b.type != AtomType_Integer)
return Error_Type;

*result = make_int(a.value.integer + b.value.integer);

return Error_OK;
}
```

The other three functions differ by only one character, so I will omit them here.

Finally we need to create bindings for our new functions in the initial environment:

```env_set(env, make_sym("+"), make_builtin(builtin_add));
env_set(env, make_sym("-"), make_builtin(builtin_subtract));
env_set(env, make_sym("*"), make_builtin(builtin_multiply));
env_set(env, make_sym("/"), make_builtin(builtin_divide));
```

#### Testing

We now have our very own LISP-style calculator.

```> (+ 1 1)
2
> (define x (* 6 9))
X
> x
54
> (- x 12)
42
```

In the last expression above, note that `X` is a symbol, not an integer. We have to evaluate the arguments so that `builtin_subtract` can operate on the integer value bound to `X` and not the symbol `X` itself. Similarly the value bound to `X` is the integer result of evaluating the expression `(* 6 9)`.