### Function Identities

One of the first features one will encounter when exploring Clojure (and most Lisps that I am familiar with) is that its arithmetical operations can take any number of arguments.

``````(+ 1 2 3 4 5)
;=> 15
``````

This feature is very convenient, but if you are a tinkerer then you may quickly encounter something about Clojure that seems odd, or at least surprising. What happens if you pass zero arguments to the `+` function?

``````(+)
;=> 0
``````

What about `*`?

``````(*)
;=> 1
``````

For addition and multiplication, the values `0` and `1` are known as the identities for each function respectively. Some of you may already know of this and others may intuitively get why they are this way.

## Iterative and Applicative Examples

In words, the results thus observed can be summarized as:

• The sum of no numbers is 0
• The product of no numbers is 1

Ignoring the mathematical aspects for now, how would similar behavior manifest itself in “real word” code? An insight can be found in the way one might implement a sum function in an classically imperative way (using Ruby to illustrate):

``````def summer(*args)
result = 0
args.each {|x| result += x}
result
end
``````

An applicative solution proves more succinct, but the principle is the same:

``````def summer(*args)
args.inject(0) {|x,y| x + y}
end
``````

Both yielding:

``````summer(1,2,3,4,5)
#=> 15

summer()
#=> 0
``````

As you can see, both implementations of `summer` use an accumulator (explicit in the first case, and implicit in the second) initialized to `0`. When the function is passed no args then the looping is never performed and the initializer `0` is returned. Pretty clear right?

## Σ and ∏

Why not simply restrict `+` to two arguments and make it signal an error when less or more are given? Surely this would be more intuitive no? Well, it depends on whose intuition you’re talking about. A mathematician would have no problem with the behavior outlined above. Because to a mathematician Clojure’s addition function does not implement `+`, it implements something closer to Σ (and in the case of `*`, )1. For the infix plus it makes no sense to allow zero arguments, but for Σ it does. But these are simply restrictions of notation and not emblematic of any deeper truths.

## But Why?

As you’ve noticed, I haven’t really explained why function identities are important. Indeed, there is more that can be said about function identities, but this post is already longer than I intended, so I’ll hold off on that discussion for another day. However, for now think about this question:

Assume that the identities for addition and multiplication were replaced by arity exceptions. What abilities would you lose?

I’ll answer this question next time.2

:F

1. Clojure’s `+` and `*` is not exactly Σ and , but they’re close enough for the sake of this discussion.

2. Unless someone beats me to it.