# Closure

Erg subroutines have a feature called a "closure" that captures external variables.

``````outer = 1
f x = outer + x
assert f(1) == 2
``````

As with immutable objects, mutable objects can also be captured.

``````sum = !0
for! 1..10, i =>
assert sum == 45

p!x=
p!(1)
assert sum == 46
``````

Note, however, that functions cannot capture mutable objects. If a mutable object can be referenced in a function, you can write code like the following.

``````# !!! This code actually gives an error !!!
i = !0
f x = i + x
assert f 1 == 1
assert f 1 == 2
``````

The function should return the same value for the same arguments, but the assumption is broken. Note that `i` is evaluated only at call time.

Call `.clone` if you want the contents of the mutable object at the time the function was defined.

``````i = !0
immut_i = i.clone().freeze()
fx = immut_i + x
assert f 1 == 1
assert f 1 == 1
``````

## avoid mutable state, functional programming

``````# Erg
sum = !0
for! 1..10, i =>
assert sum == 45
``````

The equivalent program above can be written in Python as follows:

``````# Python
sum = 0
for i in range(1, 10):
sum += i
assert sum == 45
``````

However, Erg recommends a simpler notation. Instead of carrying around state using subroutines and mutable objects, use a style of localizing state using functions. This is called functional programming.

``````# Functional style
sum = (1..10).sum()
assert sum == 45
``````

The code above gives exactly the same result as before, but you can see that this one is much simpler.

The `fold` function can be used to do more than sum. `fold` is an iterator method that executes the argument `f` for each iteration. The initial value of the counter that accumulates results is specified in `init` and accumulated in `acc`.

``````# start with 0, result will
sum = (1..10).fold(init: 0, f: (acc, i) -> acc + i)
assert sum == 45
``````

Erg is designed to be a natural succinct description of programming with immutable objects.