Church Booleans

2025-11-24T00:00:00+00:00

In the last post, I covered the basics of Lambda calculus</a> and its lack of built-in data types. Church encoding defines a way to represent data types as pure functions. In this post, I'll explore church booleans and control flow, and implement them using Python.</p>

Booleans as functions</h2>
Booleans are plain functions that take two arguments.</p>

`true</code> always returns the first argument,</li>`
`false</code> always returns the second argument.</li> </ul>`
`𝛌a.𝛌b a # True 𝛌a.𝛌b b # False </code></pre> In Python, I can define these two functions for booleans.</p>`
`def true(a, b): return a def false(a, b): return b true(1, 2) # -> 1 false(1, 2) # -> 2 </code></pre> To understand why this works more clearly we'll look at control flow.</p>`
Control flow constructs in Python</h2>
In Python, `if</code> is a special language construct that looks like this:</p>`
`if TRUE: BRANCH 1 else: BRANCH 2 </code></pre> Why can't it be a function? I'll try to define if</code> as a function using the boolean functions.</p>`
`def bad_if(bool_func, b1, b2): return bool_func(b1, b2) </code></pre> If the implementation is correct, it must evaluate exactly one branch. To check this, I'll call the bad_if</code> function with two branches.</p>`>>> bad_if(false, 2+2, 2-2) 0 >>> bad_if(true, 2+2, 2-2) 4 </code></pre> At first glance it looks correct. But we need to make sure that Python isn't evaluating both branches. I'll call bad_if</code> with two print</code> statements instead.</p> >>> bad_if(true, print("Branch 1"), print("Branch 2")) Branch 1 Branch 2 </code></pre> This shows that Python did actually evaluate both branches. This happens because Python eagerly evaluates the arguments before the function call. It then passes the value of the evaluation to the function. So the bad_if</code> call is equivalent to this:</p> b1 = print("Branch 1") # -> None b2 = print("Branch 2") # -> None bad_if(true, b1, b2) # -> None </code></pre> Because of the eager evaluation, Python needs a special syntax for control flow to avoid accidentally evaluating both branches.</p> Conditionals in Lambda Calculus</h2> In contrast to Python's eager evaluation, Lambda calculus only evaluates the arguments when β-reduction</a> requires the value. So a function call similar to bad_if</code> behaves very differently in Lambda calculus.</p> bad_if(true, print("Branch 1"), print("Branch 2")) true(print("Branch 1"), print("Branch 2")) # Reduce bad_if print("Branch 1") # Reduce true, returns first argument. </code></pre> Because of lazy evaluation, if the argument is not used then it will not be evaluated. So, we can define if</code> as a pure function in Lambda calculus.</p> 𝛌f.𝛌a.𝛌b (f a b) </code></pre> To force lazy evaluation in Python, we can wrap the branches in a Lambda</strong>. We can then call the functions returned by the boolean function.</p> def good_if(bool_func, b1, b2): # Notice we are calling the result from bool_func. return bool_func(b1, b2)() </code></pre> I'll call the good_if</code> with two branch lambdas. We can see that it correctly evaluates exactly one branch.</p> >>> good_if(true, lambda: print("branch 1"), lambda: print("branch 2")) branch 1 >>> good_if(false, lambda: print("branch 1"), lambda: print("branch 2")) branch 2 </code></pre> Conclusion</h2> Church encoding shows how expressive Lambda calculus can be, and how higher-level constructs can be built from regular functions. There's much more to explore in future posts.</p>

Lambda Calculus

2025-11-17T00:00:00+00:00

Many modern programming languages trace their roots back to Lisp, which in turn builds on ideas from lambda calculus. In this post, I explore the core ideas of lambda calculus.</p>

What is lambda calculus</h2>
For the longest time, I had the impression that lambda calculus has something to do with the calculus from high school mathematics. I was wrong, calculus</em> here simply means to calculate.</p>
Lambda calculus is a system to define any computation. Think of it like an abstract programming language to express programs. It does so using simple ideas: variables, functions and their application.</p>

Basic constructs</h2>
Lambda calculus defines two basic constructs. These are sufficient to model any computation.</p>

Variables</strong></p>
Variables are symbols that act as identifiers in the computation. Variables can be free or bound to a function's scope (parameter).</p>
x # x is free </code></pre> But the variables don't behave like programming languages. So, you cannot assign values to them.</p> </li> Functions</strong></p> Functions take arguments and perform some computation. The arguments are bound</em> variables in the function's scope.</p> This is a simple function that takes one argument x</code> and returns it.</p> 𝛌y. y # y is bound </code></pre> Sidenote: A function can only take a single argument. But multiple arguments can be simulated by defining nested functions.</p> 𝛌y.𝛌z y </code></pre> </li> </ul> Function application and β-reduction</h2> Functions are not useful on their own. To use the functions, you can apply them to arguments. Lambda calculus defines how functions are computed: β-reduction.</p> β-reduction is a fancy term for repeated substitution. The functions are computed by progressively substituting bound variables within the function body.</p> This is a contrived example to visualize β-reduction properly. Here is a nested function that takes two arguments and by repeated substitution, we get the result.</p> (𝛌x.𝛌y. x) A B (𝛌y. A) B # First reduction for outer function. A # Second reduction for inner function. </code></pre> Conclusion</h2> That's it, there is no construct for conditionals, data types, loops etc. But curiously, it is possible to encode high-level constructs using these basic ideas. In a future post, I'll explore church encodings</em> to encode conditionals and integers in lambda calculus.</p>

Ankit Gadiya - programming-theory

Church Booleans

Booleans as functions</h2> Booleans are plain functions that take two arguments.</p> true</code> always returns the first argument,</li>

Control flow constructs in Python</h2> In Python, if</code> is a special language construct that looks like this:</p>

Conclusion</h2> Church encoding shows how expressive Lambda calculus can be, and how higher-level constructs can be built from regular functions. There's much more to explore in future posts.</p>

Lambda Calculus

Conclusion</h2> That's it, there is no construct for conditionals, data types, loops etc. But curiously, it is possible to encode high-level constructs using these basic ideas. In a future post, I'll explore church encodings</em> to encode conditionals and integers in lambda calculus.</p>

Conclusion</h2>
Church encoding shows how expressive Lambda calculus can be, and how higher-level constructs can be built from regular functions. There's much more to explore in future posts.</p>

Conclusion</h2>
That's it, there is no construct for conditionals, data types, loops etc. But curiously, it is possible to encode high-level constructs using these basic ideas. In a future post, I'll explore church encodings</em> to encode conditionals and integers in lambda calculus.</p>