Computerphile has a really good video that covers the fundamental ideas of lambda calculus, which is the basis of most functional programming languages. One of the example it went throught is encoding boolean values (true/false) using pure functions - it really bended my mind.
The fundamental idea of a boolean value is making a choice. So, the encoding of boolean values encode that idea! The true value can be encoded as a function that takes two inputs, x and y, and return the first input, x, that is, it chooses the first input. Likewise, the false value takes two inputs and chooses the second input:
true <- structure(function(x, y) x, class = c("true", "bool")) false <- structure(function(x, y) y, class = c("false", "bool")) # add a print method so they display nicer print.bool <- function(x) cat(class(x), "\n")
true ## true false ## false
Next let’s define logical operations on them. The first one that comes to one’s mind is perhaps negation. This is perhaps a little mind bending for the first time, but here it goes:
# `!` is a generic function in r, so we can add methods to it `!.bool` <- function(x) x(false, true)
Remeber that the boolean values are functions and the true value chooses it’s first input. In the above definition of negation, we simply set the first input to false, so true chooses false, and we set the second input to true so false chooses true - and that’s negation!:
!true ## false !false ## true
The video left a little puzzle to solve: how to define other logical operations in this style, such as AND, OR and XOR? So I had a go and totally bended my mind (and the definition is so simple!):
AND is basically a function that uses it’s first input to choose between the second input and false
# `&` is generic `&.bool` <- function(x, y) x(y, false) true & true ## true false & true ## false true & false ## false false & false ## false
OR is a function that uses it’s first input to choose between true and the second input:
# `|` is generic `|.bool` <- function(x, y) x(true, y) true | true ## true false | true ## true true | false ## true false | false ## false
XOR is a function that uses it’s first input to choos between the negation of the second input and false:
# `xor` is generic xor.bool <- function(x, y) x(!y, false) xor(true, false) ## true xor(false, true) ## true xor(false, false) ## false xor(true, true) ## false
Pretty sure there’re other definitions, but I’m just totally mind blowed by this style of thinking. Perhaps next question is, how to define integer and integer operations in this functional style? And how about floating numbers, characters etc? Recently I learnt a few functional programming languages and techniques and it really bends my mind and broadens my view a lot. I’m hoping to learn more and share more!