# 2. Using Modules

Up to this point, you have written single expressions and evaluated them on the command-line. However, sometimes you want to split your code into multiple functions or include common libraries. In order to do things like that, you will need to understand what modules are.

## Modules​

The `mod` operator creates a context for converting the usage of constants into a single expression.

note

Functions inside the module will not have direct access to the solution, so values you need access to will need to be passed in as a function parameter manually.

In other words, there is no concept of scope.

This module will add two arbitrary values together:

``(mod (first second)    (+ first second))``

And this is an example of defining a constant and a function, followed by their usage:

``;;; Raises the number by one order of magnitude.(mod (value)    ; Defines a constant value with a name.    (defconstant ORDER_OF_MAGNITUDE 10)    ; Defines a function that can be called with a value.    (defun raise_magnitude (value)        (* value ORDER_OF_MAGNITUDE)    )    ; Calls the previously defined function.    (raise_magnitude value))``
1. The module takes in a `value` parameter.
2. `ORDER_OF_MAGNITUDE` is defined as 10.
3. The `raise_magnitude` function takes in a `value` parameter (this is different from the `value` defined as a module parameter).
4. Returns the `value` function parameter multiplied by the `ORDER_OF_MAGNITUDE`.
5. Calls the function with the module parameter `value`.

## Example​

By now you have seen how some aspects of the language work, and we can use these concepts to write and run a simple Chialisp program. We will write a module that calculates the factorial of a number using recursion.

Put this in a file named `factorial.clsp`:

factorial.clsp
``;;; Calculates a factorial recursively.;;; f(n) = n * f(n - 1);;; f(n) = n if n <= 2(mod (number)    ; Defines the factorial function.    (defun factorial (number)        (if (> number 1)            (* number (factorial (- number 1)))            1        )    )    ; Calls the function with the number provided.    (factorial number))``

Run this example with the following command:

``brun "\$(run factorial.clsp)" "(5)"``

It will compile it and run the result with a solution where `number` is 5. The result of this should be the factorial of that number, which is 120. There were a few new operators used in these examples. For more information, you should refer to the operator reference. Below is a detailed explanation of how this works.

1. The module takes in a `number` parameter.
2. The `factorial` function also takes in a `number` parameter.
3. If the number is greater than 2, returns the number times the previous factorial.
4. Otherwise, returns the number itself.
5. Call the recursive function with the `number` module parameter.

We can visualize this function with the input 5 as follows:

``(factorial 5)(* 5 (factorial 4))(* 5 (* 4 (factorial 3)))(* 5 (* 4 (* 3 (factorial 2))))(* 5 (* 4 (* 3 (* 2 (factorial 1)))))(* 5 (* 4 (* 3 (* 2 1))))``

Which then simplifies like this:

``(* 5 (* 4 (* 3 2)))(* 5 (* 4 6))(* 5 24)120``

Everything that would normally be written using iteration in an imperative language, for example array modification, is instead written using recursion in Chialisp. It can be hard to understand at first, but eventually it will make more and more sense.

## Conclusion​

Modules allow you to use functional programming in Chialisp, which makes writing it feel more natural. It also allows you to reuse your code and express it in a more clear way.

If you have any questions about modules, or anything else, remember to come ask questions on our Keybase team.