more fun

Author: nikmy

lambda/church/boolean.go

@@ -0,0 +1,57 @@
+package church
+
+type Boolean = Term
+
+// True If Else == \If.\Else.If
+func True(iF Term) Term {
+	return func(eLse Term) Term { return iF }
+}
+
+// False If Else == \If.\Else.Else
+func False(iF Term) Term {
+	return Zero(iF)
+}
+
+/*
+	Simplified Syntax:
+		A ? B : C == \A.ABC
+*/
+
+// Not p == p ? False : True
+func Not(p Boolean) Boolean {
+	return p(False)(True)
+}
+
+// And p q == p ? q : p
+func And(p Boolean) Boolean {
+	return func(q Boolean) Boolean { return p(q)(p) }
+}
+
+// Or p q == p ? p : q
+func Or(p Boolean) Boolean {
+	return func(q Boolean) Boolean { return p(p)(q) }
+}
+
+// Xor p q == p ? not q : q
+func Xor(p Boolean) Boolean {
+	return func(q Term) Term { return p(Not(q))(q) }
+}
+
+// Pair x y p == \x.\y.\p.pxy
+func Pair(left Term) Term {
+	return func(right Term) Term {
+		return func(p Term) Term { return p(left)(right) }
+	}
+}
+
+// Left == \p . p True
+// Left (Pair x y) = x
+func Left(p Term) Term {
+	return p(True)
+}
+
+// Right == \p . p False
+// Right (Pair x y) = y
+func Right(p Term) Term {
+	return p(False)
+}

lambda/church/boolean_test.go

@@ -0,0 +1,67 @@
+package church
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func evalBool(b Boolean) bool {
+	var (
+		value  bool
+		mark   Term = func(Term) Term { value = true; return nil }
+		unmark Term = func(Term) Term { value = false; return nil }
+	)
+
+	b(mark)(unmark)(False)
+
+	return value
+}
+
+func assertFalse(t *testing.T, b Boolean) {
+	assert.False(t, evalBool(b))
+}
+
+func assertTrue(t *testing.T, b Boolean) {
+	assert.True(t, evalBool(b))
+}
+
+func TestBool(t *testing.T) {
+	assertFalse(t, False)
+	assertTrue(t, True)
+}
+
+func TestNot(t *testing.T) {
+	assertFalse(t, Not(True))
+	assertTrue(t, Not(False))
+}
+
+func TestAnd(t *testing.T) {
+	assertFalse(t, And2(False, False))
+	assertFalse(t, And2(False, True))
+	assertFalse(t, And2(True, False))
+	assertTrue(t, And2(True, True))
+}
+
+func TestOr(t *testing.T) {
+	assertFalse(t, Or2(False, False))
+	assertTrue(t, Or2(False, True))
+	assertTrue(t, Or2(True, False))
+	assertTrue(t, Or2(True, True))
+}
+
+func TestXor(t *testing.T) {
+	assertFalse(t, Xor2(False, False))
+	assertTrue(t, Xor2(True, False))
+	assertTrue(t, Xor2(False, True))
+	assertFalse(t, Xor2(True, True))
+}
+
+func TestPair(t *testing.T) {
+	p := Pair2(True, False)
+	assertTrue(t, Left(p))
+	assertFalse(t, Right(p))
+
+	assert.Equal(t, 0, evalInt(Left(Pair2(Zero, One))))
+	assert.Equal(t, 1, evalInt(Right(Pair2(Zero, One))))
+}

lambda/church/compare.go

@@ -0,0 +1,32 @@
+package church
+
+// IsZero n == n (\x.False) True
+//
+// explanation: if n equals Zero, it will take
+// second argument (which is True), otherwise
+// it will chain  (\x.False) ... (\x.False) True,
+// which is always equal to False
+func IsZero(n Numeral) Boolean {
+	return n(func(Term) Term { return False })(True)
+}
+
+// LessOrEqual m n == IsZero (Sub m n)
+func LessOrEqual(m Numeral) Term {
+	return func(n Numeral) Boolean {
+		return IsZero(Sub(m)(n))
+	}
+}
+
+// Less m n == Not (LessOrEqual n m)
+func Less(m Numeral) Term {
+	return func(n Term) Term {
+		return Not(LessOrEqual(n)(m))
+	}
+}
+
+// Equal m n == And (LessOrEqual m n) (LessOrEqual n m)
+func Equal(m Numeral) Term {
+	return func(n Numeral) Boolean {
+		return And(LessOrEqual(m)(n))(LessOrEqual(n)(m))
+	}
+}

lambda/church/compare_test.go

@@ -0,0 +1,40 @@
+package church
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func assertBool(t *testing.T, exp bool, got Boolean) {
+	assert.Equal(t, exp, evalBool(got))
+}
+
+func TestCompare(t *testing.T) {
+	// IsZero
+	assertTrue(t, IsZero(Zero))
+	for _, n := range nums[1:] {
+		assertFalse(t, IsZero(n))
+	}
+
+	// LessOrEqual
+	for i, a := range nums {
+		for j, b := range nums {
+			assertBool(t, i <= j, LessOrEqual2(a, b))
+		}
+	}
+
+	// Less
+	for i, a := range nums {
+		for j, b := range nums {
+			assertBool(t, i < j, Less2(a, b))
+		}
+	}
+
+	// Equal
+	for i, a := range nums {
+		for j, b := range nums {
+			assertBool(t, i == j, Equal2(a, b))
+		}
+	}
+}

lambda/church/multiarg.go

@@ -0,0 +1,15 @@
+package church
+
+func Add2(m, n Numeral) Numeral { return Add(m)(n) }
+func Mul2(m, n Numeral) Numeral { return Mul(m)(n) }
+func Sub2(m, n Numeral) Numeral { return Sub(m)(n) }
+
+func Xor2(p, q Boolean) Boolean { return Xor(p)(q) }
+func And2(p, q Boolean) Boolean { return And(p)(q) }
+func Or2(p, q Boolean) Boolean  { return Or(p)(q) }
+
+func Pair2(x, y Term) Term { return Pair(x)(y) }
+
+func LessOrEqual2(m, n Numeral) Boolean { return LessOrEqual(m)(n) }
+func Less2(m, n Numeral) Boolean        { return Less(m)(n) }
+func Equal2(m, n Numeral) Boolean       { return Equal(m)(n) }

lambda/church/numeral.go

@@ -1,49 +1,61 @@
 package church
 
-import . "github.com/nikmy/algo/lambda/function"
+// Term is lambda-abstraction
+type Term func(Term) Term
 
-func FixedPoint(f Numeral) Numeral {
-	return f
-}
-
-// Numeral n f x == f^n(x) = f(f(...f(x)...)...)
-type Numeral Lambda[Numeral, Numeral]
+// Numeral is such n that n f x == \f.f^n(x) = \f.f(f(...f(x)...)...)
+type Numeral = Term
 
 // Zero == \f.\x.x
-func Zero(_ Numeral) Numeral {
-	return func(x Numeral) Numeral { return x }
+func Zero(_ Term) Term {
+	return func(x Term) Term { return x }
 }
 
 // One == \f.\x.fx
-func One(f Numeral) Numeral {
-	return func(x Numeral) Numeral { return f(x) }
+func One(f Term) Term {
+	return func(x Term) Term { return f(x) }
 }
 
-// Inc n f == f (n f)
+// Inc n f == \f.\n.f(nf)
 func Inc(n Numeral) Numeral {
-	return func(f Numeral) Numeral {
-		return func(x Numeral) Numeral { return f(n(f)(x)) }
+	return func(f Term) Term {
+		return func(x Term) Term { return f(n(f)(x)) }
 	}
 }
 
-// Add m n == (m Inc) n
-func Add(m Numeral) Numeral {
+// Add m n == \m.\n.m Inc n
+func Add(m Numeral) Term {
 	return func(n Numeral) Numeral {
 		return m(Inc)(n)
 	}
 }
 
-func Add2(m, n Numeral) Numeral {
-	return Add(m)(n)
-}
-
-// Mul m n == m (Add n) Zero
-func Mul(m Numeral) Numeral {
+// Mul m n == \m.\n.m (Add n) Zero
+func Mul(m Numeral) Term {
 	return func(n Numeral) Numeral {
 		return m(Add(n))(Zero)
 	}
 }
 
-func Mul2(m, n Numeral) Numeral {
-	return Mul(m)(n)
+/*
+	Kleene's trick:
+
+	Let's define incStep(N) as Nth iteration of { Pair _ n |-> Pair n (Inc n) },
+	so it maps (Pair `0` `0`) to (Pair (`N-1` f) (`N` f)), and the left side
+	of N(incStep)(Pair 0 0) is "decremented" N
+*/
+func incStep(p Term) Term {
+	return Pair(Right(p))(Inc(Right(p)))
+}
+
+// Dec == \n.Left[ n incStep (Pair Zero Zero) ]
+func Dec(n Numeral) Numeral {
+	return Left(n(incStep)(Pair(Zero)(Zero)))
+}
+
+// Sub m n == m Dec n
+func Sub(m Numeral) Term {
+	return func(n Term) Numeral {
+		return n(Dec)(m)
+	}
 }