If condition on lambda calculus

lambda_calculus.rb

# Rules: A lamda always has 1 parameter, nothing more, nothing less
# Useful Content: https://en.wikipedia.org/wiki/Church_encoding

# Identity lambda
IDENTITY = ->x { x }

# True, returns the first argument
TT = ->x { ->y { x } }

# False, returns the last argument
FF = ->x { ->y { y } }

# Conditional lambda
##
# Call boolean(TT or FF) passing 2 lambdas
# One for truth case
# One for false case
IF = ->boolean {->tCase {->fCase {
  boolean.call(tCase).call(fCase).call(IDENTITY)
} } }

# Testing the conditional lambda
IF.call(TT).call(->_ { puts "T" }).call(->_ { puts "F" }) #=> "T"
IF.call(FF).call(->_ { puts "T" }).call(->_ { puts "F" }) #=> "F"

###

# Avoiding Calling IF twite to test 
ASSERT = -> (boolean) {
  IF.(boolean).(->_ { puts "T" }).(->_ { puts "F" })
}

# Testing the conditional lambda without rewriting
ASSERT.(TT) # => "T"
ASSERT.(FF) # => "F"


### AND Operator
AND = ->(p) { ->(q) { p.call(q).call(p) } }

AND.call(TT).call(TT) # => TT
AND.call(TT).call(FF) # => FF
AND.call(FF).call(TT) # => FF
AND.call(FF).call(FF) # => FF

ASSERT.(
  AND.call(TT).call(TT)
) # => "T"

ASSERT.(
  AND.call(TT).call(FF)
) # => "F"

ASSERT.(
  AND.call(FF).call(TT)
) # => "F"

ASSERT.(
  AND.call(FF).call(FF)
) # => "F"

# We could also use ruby to check
AND.call(TT).call(TT) == TT
AND.call(TT).call(FF) == FF
AND.call(FF).call(TT) == FF
AND.call(FF).call(FF) == FF


### OR Operator
OR = ->(p) { ->(q) { p.call(p).call(q) } }

OR.call(TT).call(TT) # => TT
OR.call(TT).call(FF) # => TT
OR.call(FF).call(TT) # => TT
OR.call(FF).call(FF) # => FF

ASSERT.(
  OR.call(TT).call(TT)
) # => "T"

ASSERT.(
  OR.call(TT).call(FF)
) # => "T"

ASSERT.(
  OR.call(FF).call(TT)
) # => "T"

ASSERT.(
  OR.call(FF).call(FF)
) # => "F"


# We could also use ruby to check
OR.call(TT).call(TT) == TT
OR.call(TT).call(FF) == TT
OR.call(FF).call(TT) == TT
OR.call(FF).call(FF) == FF