I'm reading through a bit of SICP right now and came across an example problem which casually throws Church Numerals in your face.

Man, listen, I'm pretty dumb. I know that. You know that. People I pass on the street know that, deep in their hearts and with the certainty of *fact*.

Anyway, Church Numerals. I stumble on 'em every time I come across 'em. Them and the rest of lambda calculus really, jeez, it just falls right out of my head. So, let me go ahead and capture my understanding in a blog before it escapes again.

Church Numerals are just natural numbers, simple as that. The thing is, though, and this is neat, they're numbers *without* numbers - they're encoded with functions. It's, okay, check it.

Instead of thinking of numbers as, well, numbers, we can think of them as things which can apply a function some number of times. Whoa, easy there, don't worry, we'll take it slow.

Okay, so, let's start with zero. Our function `zero`

will take a function `f`

and return a function which will apply it *zero* times. Easy-peasy:

zero = # given f (f) -> # return a function of x (x) -> # which doesn't apply f to x return x

Now, the increment function `inc`

will take a number and return its successor - i.e., a function that applies `f`

one additional time. Shouldn't be too bad:

inc = # given n-1 (prevN) -> # return a function which takes f (f) -> # and returns a function of x (x) -> # which applies f to x n-1 times result = prevN(f)(x) # and applies f once more return f(result)

Given `inc`

, we can define a couple of other numbers for the hell of it:

one = inc zero two = inc one

Now that we've our beautiful-looking numbers, how do we use 'em? Remember, given a number, we can pass it a function `f`

and it'll return a function which applies `f`

n times. So, let's say we were really interested in adding periods to things. We could write an `addPeriod`

function:

addPeriod = (s) -> return s + "."

And we use this with a string, obvs:

addPeriod("") # => "."

Using our numbers, we can apply this bad boy zero times:

zero(addPeriod)("") # => ""

How dang exciting is that? Our zero produced zero periods by applying `addPeriod`

zero times! Just like you'd expect!

Okay, I can see it in your eyes. You want something with a little more razzle-dazzle. Well, prepare to get your mind blown. Let's check out the number two:

two(addPeriod)("") # => ".."

Rad, right? `two`

calls `one`

, `one`

calls `zero`

, `zero`

returns `""`

, `one`

adds a period, and finally, `two`

adds another period. Couldn't be simpler.

Boy, ain't this grand? I can't imagine why anybody would represent numbers the old, boring way ever again.