awkward

Author: nikmy

lambda/church/README.md

@@ -7,6 +7,14 @@
 It is amazing that in Go it is allowed to declare strange
 recursive types, which one is `Term`:
 ```go
+package church
+
+// Term is an abstraction of a function
+// that can be applied any number of
+// times to itself. It is the base
+// concept in lambda calculus. There
+// will be aliases for this type for
+// better readability.
 type Term func(Term) Term
 ```
 It means that we can implement pure lambda calculus. 'purity'
@@ -35,3 +43,4 @@ If you want to explore this funny code, I have an order for you:
 5. `compare.go` — they will save us
 6. `dirty.go` — disgusting hacks
 7. `numeral.go` — the main boss, division and mod
+8. `klop.go` — are you sure?

lambda/church/klop.go

@@ -0,0 +1,37 @@
+package church
+
+import "github.com/nikmy/algo/tools/slices"
+
+func k(a Term) Term {
+	return func(b Term) Term { return func(c Term) Term { return func(d Term) Term { return func(e Term) Term { return func(f Term) Term { return func(g Term) Term {
+		return func(h Term) Term { return func(i Term) Term { return func(j Term) Term { return func(k Term) Term { return func(l Term) Term { return func(m Term) Term {
+			return func(n Term) Term { return func(o Term) Term { return func(p Term) Term { return func(q Term) Term { return func(s Term) Term { return func(t Term) Term {
+				return func(u Term) Term { return func(v Term) Term { return func(w Term) Term { return func(x Term) Term { return func(y Term) Term { return func(z Term) Term {
+					return func(r Term) Term {
+						return r(compose(
+							compose(t, h, i, s),
+							compose(i, s),
+							compose(a),
+							compose(f, i, x, e, d),
+							compose(p, o, i, n, t),
+							compose(c, o, m, b, i, n, a, t, o, r),
+						))
+					}
+				}}}}}}
+			}}}}}}
+		}}}}}}
+	}}}}}}
+}
+
+func compose(ts ...Term) Term {
+	return func(x Term) Term {
+		for _, t := range ts {
+			x = t(x)
+		}
+		return x
+	}
+}
+
+func yKlop(g Term) Term {
+	return compose(slices.Repeat[Term](k, 26)...)(g)
+}

lambda/church/numeral.go

@@ -35,11 +35,11 @@ func Mul(m Numeral) Term {
 }
 
 /*
-Kleene's trick:
+	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
+	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` `N`), 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)))
@@ -79,37 +79,25 @@ func Sub(m Numeral) Term {
 
 	So, if a solution exists, Div is a fixed point of genDiv
 	combinator. To find a fixed point, we can use powerful
-	tool Y-combinator:
+	tool Y-combinator (see y_comb.go):
 
-		YComb == (\x.\y.y(xxy))(\x.\y.y(xxy))
+		yComb == (\x.\y.y(xxy))(\x.\y.y(xxy))
 
 	For any combinator F:
 
-		YComb F = (\x.\y.y(xxy)) (\x.\y.y(xxy)) F
-				= F((\x.\y.y(xxy)) (\x.\y.y(xxy)) F)
-				= F(YComb F)
+		yComb F = (\x.\y.y(xxy)) (\x.\y.y(xxy)) F
+			= F((\x.\y.y(xxy)) (\x.\y.y(xxy)) F)
+			= F(yComb F)
 
 	(if you don't understand the first transition, just
 	substitute (\x.\y.y(xxy)) as x and F as y into the first
 	closure).
 
 	So, now we have a formula for Div:
 
-		Div == YComb (\G . Less(m, n) Zero Inc(G (Sub m n) n))
+		Div == yComb (\G . Less(m, n) Zero Inc(G (Sub m n) n))
 */
 
-// yCombPart == (\x.\y.y(xxy))
-func yCombPart(x Term) Term {
-	return func(y Term) Term {
-		return y(x(x)(y))
-	}
-}
-
-// YComb == (\x.\y.y(xxy))(\x.\y.y(xxy))
-func YComb(g Term) Term {
-	return (yCombPart)(yCombPart)(g)
-}
-
 // genDiv G == Less(m, n) Zero Inc(G (Sub m n) n)
 func genDiv(g Term) Term {
 	return func(m Numeral) Term {
@@ -119,9 +107,9 @@ func genDiv(g Term) Term {
 	}
 }
 
-// div == YComb genDiv
+// div == yComb genDiv
 func div(m Numeral) Term {
-	return YComb(genDiv)(m)
+	return yComb(genDiv)(m)
 }
 
 var _ = div // unfortunately, it does not actually work :(
@@ -133,7 +121,7 @@ var _ = div // unfortunately, it does not actually work :(
 // overflow callstack (because go runtime
 // evaluates all arguments before apply).
 //
-// Test for this function does not check YComb
+// Test for this function does not check yComb
 // trick, but it checks recursive formula.
 func Div(m Numeral) Term {
 	return func(n Term) Numeral {

lambda/church/y_comb.go

@@ -0,0 +1,13 @@
+package church
+
+// yCombPart == (\x.\y.y(xxy))
+func yCombPart(x Term) Term {
+	return func(y Term) Term {
+		return y(x(x)(y))
+	}
+}
+
+// yComb == (\x.\y.y(xxy))(\x.\y.y(xxy))
+func yComb(g Term) Term {
+	return (yCombPart)(yCombPart)(g)
+}