Lambda Calculus by Dustin Mulcahey

Lambda Calculus
Dustin Mulcahey

First, a crash course in mathematical
logic...

For computer scientists, the most interesting part of
this discussion is Hilbert’s Entscheidungsproblem.


Entscheidungsproblem: Given a mathematical
statement, is there an algorithm that will compute a
proof or a refutation of that statement?


Entscheidungsproblem: Given a mathematical
statement, is there an algorithm that will compute a
proof or a refutation of that statement?
At the time of its statement by Hilbert, there was
no formalization of “algorithm”.

Fast-forward to the late 1920s...

Fast-forward to the late 1920s...

Schoenﬁnkel: “Bound variables are bad. (or, at
least, unnecessary)”

Schoenfinkel defined the basic combinators that
form the “combinatory logic” (SKI). We’ll define
these in terms of the lambda calculus, once we’ve
defined that.

Schoenfinkel defined the basic combinators that
form the “combinatory logic” (SKI). We’ll define
these in terms of the lambda calculus, once we’ve
defined that.
Haskell Curry also formulated the concept of
“combinator” in his efforts to unambiguously define
substitution, which had been rather loosely
described up until his time (and continues to be
loosely described up to this day).

Schoenﬁnkel also seems to have originated the
notion of “currying” (named after Haskell Curry).
This is the idea that you can take a two argument
function
F (x, y )
and express it as a one argument function that is
valued in functions:
(f (x))(y )

Finally, on to Alonzo Church!

Goal: a new formal system for logic based upon the
notion of function application. He wanted
something “more natural” than Russell-Whitehead
or ZF.

The formal system that he developed is called the
lambda calculus.
Here is the identity function expressed in the
lambda calculus:

The formal system that he developed is called the
lambda calculus.
Here is the identity function expressed in the
lambda calculus:

λx.x

Why use λ for function abstraction?

Whitehead and Russell used x for class abstraction.
ˆ
If you move the hat oﬀ the x, you get ∧x.
Apparently, λx was easier to print than ∧x.

Whitehead and Russell used x for class abstraction.
ˆ
If you move the hat oﬀ the x, you get ∧x.
Apparently, λx was easier to print than ∧x.
At least, that’s how Church told it at one point.
Later in life, he claimed that he needed a symbol
and he just happened to choose λ.

In a formal system, we must give clear rules about
what sequence of symbols can be produced and how
they can be transformed. It’s very similar to
designing a programming language.

To formulate the lambda calculus, we must first fix
a set of letters that we will use for variables.
Typically, we denote these by x, y (we rarely need
more than two). Once this has been done, we
inductively define valid lambda terms:
If x is a variable, then x is a valid lambda term.
If t is a valid lambda term and x is a variable,
then (λx.t) is a valid lambda term. (Lambda
Abstraction)
If t, s are valid lambda terms, then (t s) is a
valid lambda term. (Application)

That’s it! We can now construct all sorts of lambda
terms:
x
(λx.x)
y
(y y )
((λx.x)(y y ))
(λy .((λx.x)(y y )))

(variable)
(lambda abstraction)
(variable)
(application)
(application)
(lambda abstraction)

While I have given the intuition behind the above
constructs, they are mere scribblings on paper until
we give rules for manipulating the terms. From a
proof-theoretic perspective, meaning arises from the
reduction rules of the language.

While I have given the intuition behind the above
constructs, they are mere scribblings on paper until
we give rules for manipulating the terms. From a
proof-theoretic perspective, meaning arises from the
reduction rules of the language.
This is quite diﬀerent from other notions of
meaning, such as Tarski’s deﬁnition of truth or
denotionation semantics (in fact, we shall see that
denotational semantics turns out to be an
interesting problem for the lambda calculus).

There are three rules for manipulating lambda
terms:
α-equivalence: renaming variables
β-reduction: how function application “works”
η-conversion: two functions are “the same” if
they do the same thing (extensionality)

α-equivalence lets us convert λx.x to λy .y .

α-equivalence lets us convert λx.x to λy .y . Makes
sense, right? They are both the identity function.
Generally, α-equivalence lets us rename any bound
variables.

As programmers, we use α-equivalence to reason
about lexical scoping:
x = 0
f = function(x, y) {
return x + y;
}
print f(3,4);

is equivalent to:
x = 0;
f = function(a, b) {
return a + b;
}
print f(3,4);

As you can imagine, formally deﬁning α-equivalence
is a bit tricky. We want λx.x α-equivalent to λy .y ,
but we do not want λx.(λy .x) α-equivalent to
λy .(λy .y ).

As you can imagine, formally deﬁning α-equivalence
is a bit tricky. We want λx.x α-equivalent to λy .y ,
but we do not want λx.(λy .x) α-equivalent to
λy .(λy .y ).
(The ﬁrst takes a value and produces the constant
function at that value, while the second returns the
identity function no matter what’s passed to it.)

β-reduction captures the notion of function
application. However, to formally deﬁne it, we run
in to the substitution problem again!

β-reduction captures the notion of function
application. However, to formally deﬁne it, we run
in to the substitution problem again!
Intuitively, we would like (f x) to denote the
application of a function f to an input x. Of course,
in this world, everything has the same “type”, so we
are really applying one lambda term to another.

For a simple example of β-reduction, let’s apply the
identity function to something.
((λx.x)(λy .(y y ))

For a simple example of β-reduction, let’s apply the
identity function to something.
((λx.x)(λy .(y y ))
ought to reduce to
(λy .(y y ))

How about the other way around?
((λy .(y y ))(λx.x)

((λy .(y y ))(λx.x)
((λx.x)(λx.x))

((λy .(y y ))(λx.x)
((λx.x)(λx.x))
(λx.x)

We deﬁne β-reduction as follows. Let
((λx.t) s)
be a valid lambda term with t and s lambda terms
and x a variable. The above reduces to
t[s/x]
where t[s/x] denotes the result of replacing every
occurrence of x in t by s.

Problem: what if our usage of variables is a bit too
incestuous?

incestuous?
Example:
t = (λz.(x y ))
s =z

incestuous?
Example:
t = (λz.(x y ))
s =z
Now apply β-reduction:
((λx.t) s)
((λx.(λz.(x y ))) z)
(λz.(z y ))

Whereas if we ﬁrst did α-equivalence:
t = (λw .(x y ))
s =z

Whereas if we ﬁrst did α-equivalence:
t = (λw .(x y ))
s =z
And then apply β-reduction:
((λx.t) s)
((λx.(λw .(x y ))) z)
(λw .(z y ))
The function on the previous slide applies its
parameter to the free variable y , whereas the
function on this slide does nothing with its
parameter!

So, obviously some care is needed when deﬁning
substitution.
We need to ensure that in
((λx.t) s)
that s does not contain a free variable that becomes
bound when s is substituted for x in t.

The next and ﬁnal reduction expresses the
mathematical principle of extensionality.

Informally, we say that two functions are
extensionally equal if they do the same thing.

Informally, we say that two functions are
extensionally equal if they do the same thing.
That is,
f (x)
=x +2
g (x) = x + 1 + 1
are two diﬀerent functions as I have written them,
but extensionally equal.

However (as an aside),
2

−4
f (x) = xx−2
g (x) = x + 2

Are neither equal nor extensionally equal, but
algebraically reduce to the same thing.

η-conversion captures this notion by stating that, for
lambda expressions f not containing the variable x,
(λx.(f x))
is equivalent to
f

That’s enough math! Let’s do some programming.

Well, I can do what any beginning (or intermediate,
or advanced) programmer does:
((λx.(x x))(λx.(x x)))

((λx.(x x))(λx.(x x)))
Let’s apply β-reduction:

((λx.(x x))(λx.(x x)))
Let’s apply β-reduction:
((λx.(x x))(λx.(x x)))
Yay! An inﬁnite loop!
So we see that the true strength of the lambda
calculus is the speed at which we can write down
inﬁnite computations.

Or, even better:
(λx.((x x) x)(λx.((x x) x)

Or, even better:
(λx.((x x) x)(λx.((x x) x)
(((λx.((x x) x) (λx.((x x) x)) (λx.((x x) x))

Or, even better:

(λx.((x x) x)(λx.((x x) x)
((((λx.((x x) x) (λx.((x x) x)) (λx.((x x) x)) (λx.((x x

Or, even better:

(λx.((x x) x)(λx.((x x) x)
((((λx.((x x) x) (λx.((x x) x)) (λx.((x x) x)) (λx.((x x
.
.
.
This example shows that not all lambda terms
normalize. That is, given a lambda term, you can’t
always just whack it with β-reduction until it settles
into something!

To make things that are more interesting than
non-terminating programs, we need to deﬁne some
basic things. I will now deﬁne the following:
numbers

numbers
booleans and conditionals

numbers
booleans and conditionals
recursion

The standard formulation of the natural numbers is
called the system of Church Numerals.

Intuition: The number n is n-fold composition.

Intuition: The number n is n-fold composition.
(Speaking of non-termination...)

Less cyclic: The number n is a function that takes a
function and returns the nth-fold composite of that
function.

function.
(Hmm, still looks cyclic to me.)

function.
That is,
n(f ) = f ◦ f ◦ f ◦ . . . ◦ f

function.
That is,
n(f ) = f ◦ f ◦ f ◦ . . . ◦ f
which we can denote as f ◦n .

Formally,
0 ≡ f → id

≡ λf .(λx.x)

Formally,
0 ≡ f → id
1 ≡f →f

≡ λf .(λx.x)
≡ λf .(λx.(f x))

Formally,
0 ≡ f → id
1 ≡f →f
2 ≡

≡ λf .(λx.x)
≡ λf .(λx.(f x))

Formally,
0 ≡ f → id
≡ λf .(λx.x)
1 ≡f →f
≡ λf .(λx.(f x))
2 ≡f →f ◦f

Formally,
0 ≡ f → id
≡ λf .(λx.x)
1 ≡f →f
≡ λf .(λx.(f x))
2 ≡ f → f ◦ f ≡ λf .(λx.(f (f x))

Formally,
0 ≡ f → id
≡ λf .(λx.x)
1 ≡f →f
≡ λf .(λx.(f x))
2 ≡ f → f ◦ f ≡ λf .(λx.(f (f x))
and so on...

There are two rules for constructing natural
numbers:

numbers:
0 ≡ λf .(λx.x)

numbers:
0 ≡ λf .(λx.x)
and if n is a natural number, then
n+1≡

numbers:
0 ≡ λf .(λx.x)
n + 1 ≡ succ(n) ≡

numbers:
0 ≡ λf .(λx.x)
n + 1 ≡ succ(n) ≡ λf .λx.(f ((n f ) x)

Is this deﬁnition consistent with what I’ve shown
you?
1≡

you?
1 ≡ succ(0)

you?
1 ≡ succ(0)
λf .λx.(f ((0 f ) x))

you?
1 ≡ succ(0)
λf .λx.(f ((0 f ) x))
λf .λx.(f ((λf .λx.x) f ) x))

you?
1 ≡ succ(0)
λf .λx.(f ((0 f ) x))
λf .λx.(f ((λf .λx.x) f ) x))
λf .λx.(f ((λx.x) x))

you?
1 ≡ succ(0)
λf .λx.(f
λf .λx.(f
λf .λx.(f
λf .λx.(f

((0 f ) x))
((λf .λx.x) f ) x))
((λx.x) x))
x)

You’ll notice that I’ve suddenly started using the
symbol ≡

You’ll notice that I’ve suddenly started using the
symbol ≡
If a ≡ b, I’m declaring by the powers of notation
that wherever you write a, you can also write b (and
vice versa).

Also note that succ is itself a lambda term:
succ ≡ λn.λf .λx.(f ((n f ) x))
Here, n is not boldface because I’m using it as a
variable. The user of our succ function could put
anything there! Of course, we only gaurantee good
behavior on an input that is equivalent to a natural
number (as we have deﬁned them).

Okay, we have natural numbers. How about
addition?

addition?
Intuition: n + m takes a function and composes it
n + m times.

addition?
n + m times. Strategy: Let’s write a lambda term
that applies f m times, “and then”applies it n
times.

addition?
times. In the world of functions, “and then” means
composition! So addition corresponds to
composition.

addition?
times. In the world of functions, “and then” means
composition! So addition corresponds to
composition.
add ≡ (λn.λm.λf .λx.((n f ) ((m f ) x)))

Theorem: ((add 2) 2) is equivalent to 4
Proof: (I’m going to use a mixture of deﬁnitional
equality and reductions)
((add 2) 2)

((add 2) 2)
(((λn.λm.λf .λx.((n f ) ((m f ) x))) 2) 2)

((add 2) 2)
(((λn.λm.λf .λx.((n f ) ((m f ) x))) 2) 2)
((λm.λf .λx.((2 f ) ((m f ) x))) 2)

((add 2) 2)
(((λn.λm.λf .λx.((n f ) ((m f ) x))) 2) 2)
((λm.λf .λx.((2 f ) ((m f ) x))) 2)
(λf .λx.((2 f ) ((2 f ) x)))
(λf .λx.(((λf .λx.(f (f x)) f ) ((λf .(λx.(f (f x)) f ) x)))

((add 2) 2)
(((λn.λm.λf .λx.((n f ) ((m f ) x))) 2) 2)
((λm.λf .λx.((2 f ) ((m f ) x))) 2)
(λf .λx.((2 f ) ((2 f ) x)))
(λf .λx.((λx.(f (f x)) (λx.(f (f x)) x)))

((add 2) 2)
(((λn.λm.λf .λx.((n f ) ((m f ) x))) 2) 2)
((λm.λf .λx.((2 f ) ((m f ) x))) 2)
(λf .λx.((2 f ) ((2 f ) x)))
(λf .λx.((λx.(f (f x)) (f (f x))))

((add 2) 2)
(((λn.λm.λf .λx.((n f ) ((m f ) x))) 2) 2)
((λm.λf .λx.((2 f ) ((m f ) x))) 2)
(λf .λx.((2 f ) ((2 f ) x)))
(λf .λx.((λx.(f (f x)) (f (f x))))
(λf .λx.(λf .(f (f (f (f x))))))
4

As you can see, doing arithmetic with Church
numerals is both simple and fun.
What about multiplication?

Intuition: (n ∗ m) takes a function and returns the
n ∗ mth fold composite of the function with itself.
Strategy: Make the mth composite of f n times.

Intuition: (n ∗ m) takes a function and returns the
n ∗ mth fold composite of the function with itself.
Strategy: Make the mth composite of f n times.
mult = λn.λm.λf .λx.((n (m f )) x)

Theorem: ((mult 2) 2) is equivalent to 4

Theorem: ((mult 2) 2) is equivalent to 4
Proof: This is left as an exercise for the reader.

Exponentiation is also straightforward:
Strategy: To get mn , apply n to m. Remember that
m takes a function and returns the mth fold
composite. So now we take the nth fold composite
of the function that takes a function and returns the
mth fold composite. So now we have a function
that takes a function and returns the mn th fold
composite.

composite. Clear, right? How about this:

(n m)f = (m ◦ m ◦ · · · ◦ m)f

(n m)f = (m ◦ m ◦ · · · ◦ m)f
(Remember that composition corresponds to
addition.)

In lambda form:
exp ≡ λm.λn.λf λx.(((n m) f ) x)

Subtraction is much trickier. The most
understandable way to do it (that I know of) is to
use pairing.
Idea: Instead of incrementing x to x + 1, let’s take
the pair (n, m) to the pair (m, m + 1). If we start at
(0, 0), we’ll get the following sequence:

use pairing.
(0, 0) → (0, 1) → (1, 2) → (2, 3) · · ·

use pairing.
(0, 0) → (0, 1) → (1, 2) → (2, 3) · · ·
So, to get the predecessor of n, we just do the
above process n times and then take the ﬁrst
coordinate of the result. How’s that for eﬃciency?

Okay, how do we make pairs?
Well, it will help to ﬁrst deﬁne booleans and
conditionals.

A few deﬁnitions:
true ≡ λx.λy .x

A few deﬁnitions:
true ≡ λx.λy .x
false ≡ λx.λy .y

A few deﬁnitions:
true ≡ λx.λy .x
false ≡ λx.λy .y
cond ≡ λc.λt.λf .((c t) f

To make a pair of lambda terms, we will store them
both in a cond. To get the ﬁrst, we apply cond to
true. To get the second, we apply cond to false.

To make a pair of lambda terms, we will store them
both in a cond. To get the ﬁrst, we apply cond to
true. To get the second, we apply cond to false.
pair ≡ λf .λs.λc.(((cond c)s)t)

What about my pair increment function?

paircrement ≡ λp.((pair (p false))(succ (p true)))

So, the predecessor function looks like:

So, the predecessor function looks like:
pred ≡ λn.(((n paircrement) ((pair 0) 0) true)

Also, we can detect when something is zero:
isZero ≡ λn.((n(λx. false)) true)

Phew! We now have conditionals and arithmetic.

... and with pairs, we could go ahead and deﬁne the
rationals right now. But I’m not going to.

... and with pairs, we could go ahead and deﬁne the
rationals right now. But I’m not going to.
Instead, I want to plunge into recursion!

Okay, to do recursion, I need a function to call
itself.

itself. Except in our formal system of lambda
calculus, there is no notion of variable binding. All
we have are ways of constructing lambda terms and
ways of reducing them to other lambda terms.

itself. Except in our formal system of lambda
calculus, there is no notion of variable binding. All
we have are ways of constructing lambda terms and
ways of reducing them to other lambda terms. How
do we do this?

Yes, this is where we start talking about the Y
combinator.

Yes, this is where we start talking about the Y
combinator.
There are a bunch of explanations of this thing, and
what follows is one of them.

Let’s start with a recursive function:
fact ≡ λn. ((((cond (isZero n)) 1) ((mult n) (fact
(pred n))))

Let’s start with a recursive function:
fact ≡ λn. ((((cond (isZero n)) 1) ((mult n) (fact
(pred n))))
This would only make sense if we could make
recursive deﬁnitional equalities. But, if you think
about it, if we could, then we would just be writing
forever...

Well, we can’t refer to a function by name (except
in the very limited sense of ≡). But what if we
could pass a function to itself?
fact ≡ λf . λn. ((((cond (isZero n)) 1) ((mult n) (f
(pred n))))
Well, it wouldn’t make much sense to reduce (fact
fact), since we would have to reduce (fact (pred n)),
which doesn’t make sense.

But what if we had a magic function g such that g
is equivalent to (fact g )?
Then, the following would happen (for example):

((fact g ) 4)

((fact g ) 4)
((λf . λn. ((((cond (isZero n)) 1) ((mult n) (f (pred
n)))) g ) 4)

((fact g ) 4)
n)))) g ) 4)
λn. ((((cond (isZero n)) 1) ((mult n) (g (pred n))))
4)

((fact g ) 4)
n)))) g ) 4)
4)
((((cond (isZero 4)) 1) ((mult n) (g (pred 4))))

((fact g ) 4)
n)))) g ) 4)
4)
((mult n) (g (pred 4)))

((fact g ) 4)
n)))) g ) 4)
4)
((mult n) (g 3))

((fact g ) 4)
n)))) g ) 4)
4)
((mult n) (g 3))
((mult n) ((fact g ) 3))

Such a magic g is the ﬁxed point of fact.

A ﬁxed point of a function f is a value x such that
f (x) = x

A ﬁxed point of a function f is a value x such that
f (x) = x
For example: if f (x) = x 2 then 0, 1 are the ﬁxed
points of f .

In the lambda calculus, there is a lambda term that
will compute the ﬁxed point of any other lambda
term. This is referred to as the Y -combinator.
Note that there are several ﬂavors of Y combinator.

Here’s one:
Y = λf .((λx.(f (x x)))(λx.(f (x x))))

Theorem: for any lambda term h, (Y h) is
equivalent to (h (Y h)).
Proof:

Proof:
(Y h)

Proof:
(Y h)
(λ f. ((λ x. (f (x x))) (λ x. (f (x x)))) h)

Proof:
(Y h)
(λ f. ((λ x. (f (x x))) (λ x. (f (x x)))) h)
((λ x. (h (x x))) (λ x. (h (x x)))

Proof:
(Y h)
(λ f. ((λ x. (f (x x))) (λ x. (f (x x)))) h)
((λ x. (h (x x))) (λ x. (h (x x)))
(h ((λ x. (h (x x)) (λ x. (h (x x))))

Proof:
(Y h)
(λ f. ((λ x. (f (x x))) (λ x. (f (x x)))) h)
((λ x. (h (x x))) (λ x. (h (x x)))
(h ((λ x. (h (x x)) (λ x. (h (x x))))
(h (Y h))

So really, factorial is deﬁned in two steps:
fact’ ≡ λf . λn. ((((cond (isZero n)) 1) ((mult n) (f
(pred n))))
fact ≡ (Y fact’)

Which is deﬁnitionally equivalent to this:
((λf . ((λx. (f (x x))) (λx. (f (x x)))) (λf . λn.
((((λc.λt.λf . ((c t) f (λn. ((n (λx. (λx.λy .y )))
(λx.λy .x)) n)) (λf .λx.(fx))) (((λn.λm.λf . (n (m
(f )))) n) (f ((λn. (((n (λp. (((λf .λs.λc.
((((λc.λt.λf .((c t) f ) c) s) t)) (p (λx.λy .y )))
((λf .λx. (f ((n f ) x)) (p (λx.λy .x))))))
(((λf .λs.λc. ((((λc.λt.λf .((c t) f ) c) s) t))
(λf .λx.x)) (λf .λx.x)) (λx.λy .x))) n))))))

Now that we’ve deﬁned the lambda calculus and
written a program in it, I want to discuss some
properties of the system as a whole.

The Church-Turing Thesis
Any algorithm that performs a computation can be
expressed in the λ-calculus, or by a Turing machine,
or by a recursive function (in the sense of recursion
theory).

Undecidability of Equivalence
There does not exist an algorithm that decides
whether or not two arbitrary lambda terms are
equivalent.

The Church-Rosser Theorem
In the λ-calculus, given terms t1 and t2 gotten from
a common term t by a sequence of reductions, there
exists a term s that t1 and t2 both reduce to.

The Church-Rosser Theorem
In the λ-calculus, given terms t1 and t2 gotten from
a common term t by a sequence of reductions, there
exists a term s that t1 and t2 both reduce to.
t

/t

/s

t2

1

Equivalence of the λ-calculus and combinatory logic.
Deﬁne combinators:
I = λx.x
K = λx.λy .x
S = λx.λy .λz.((x z) (y z))
Then these combinators suﬃce to construct any
lambda term, up to equivalence.

Equivalence of the λ-calculus and combinatory logic.
Deﬁne combinators:
I = λx.x
K = λx.λy .x
S = λx.λy .λz.((x z) (y z))
Then these combinators suﬃce to construct any
lambda term, up to equivalence.
For example,
Y = S (K (S I I)) (S (S (K S) K) (K (S I I)))

Correspondence between SK and propositional logic
Consider the axiom of propositional logic:
a =⇒ (b =⇒ a)

a =⇒ (b =⇒ a)
Now look at the K combinator again:
λa.λb.a

a =⇒ (b =⇒ a)
Now look at the K combinator again:
λa.λb.a
Now repeat this to yourself:
“If I have a proof of a, then given a proof of b, I still
have a proof of a”

Now consider the axiom:

(a =⇒ (b =⇒ c)) =⇒ ((a =⇒ b) =⇒ (a =⇒ c))


(a =⇒ (b =⇒ c)) =⇒ ((a =⇒ b) =⇒ (a =⇒ c))
Now look at the S combinator again:
λf .λg .λa.((f a)(g a))


(a =⇒ (b =⇒ c)) =⇒ ((a =⇒ b) =⇒ (a =⇒ c))
Now look at the S combinator again:
λf .λg .λa.((f a)(g a))
Now, repeat this to yourself:
“If I have a way f of turning proofs of a into proofs
that b implies c, then given a proof g that a implies
b, I can make a proof that a implies c.”

Really, the only sane way to think about this stuﬀ is
to appeal to category theory.

The proposition
a =⇒ (b =⇒ a)

The proposition
a =⇒ (b =⇒ a)
Corresponds to an object (“function space”). Think
of A as the set of proofs of the proposition a.
(AB )A

The proposition
a =⇒ (b =⇒ a)
(AB )A
Which, in nice categories is isomorphic to
A(A×B)

The proposition
a =⇒ (b =⇒ a)
(AB )A
Which, in nice categories is isomorphic to
A(A×B)
(All I’ve done here is uncurry.)

The latter function space contains the ﬁrst
projection (which looks an awful lot like K). The
existence of this ﬁrst projection shows that the type
AA×B is inhabited, and thus the original proposition
a =⇒ (b =⇒ a) is valid.

The correspondence between lambda expression,
logical formulas, and objects in categories is called
the Curry-Howard-Lambek correspondence.

Lambda Calculus by Dustin Mulcahey

More Related Content

What's hot (20)

Viewers also liked (11)

Similar to Lambda Calculus by Dustin Mulcahey (20)

More from Hakka Labs (20)

Recently uploaded (20)

Lambda Calculus by Dustin Mulcahey