Figuring out lambda calculus

Apr 23rd, 2019
795
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
1. -- taking notes while examining the structure, this is when I finally figured out how "two arguments were passed"
2. -- through the "f" and "x" functions
3. call a function(1)
4. f1()
5. that function is the result of another(2) function being called with a third(B) function
6. f1 = f2(B)
7. the second(2) function returns function(f) called with a forth(A) function
8. f2 = return ff(A)
9. function(x) is defined by a call to its bound function(F)
10. fx = F(x)
11. function(f) binds the passed function and returns function(x)
12. ff = fx(F)
13. finally, function(f) is called with function(A) (SEE ABOVE)
14.
15. f1() -> f2(B) -> ff(A)(B) ->
16. fx(A)(B) -> A(B) -> B
17.
18. ff(A) really means F = A & call fx(B)
19.
20. -- nesting to try to understand it better
21. (1
22.   (2
23.     (λ f .
24.       (λ x .
25.         (f x)
26.       )
27.     )
28.     (λ a . a)
29.   )
30.   (λ b . b)
31. )
32.
33. -- attempting a syntax that I understand better
34. λ x . (f x)     => fn X(x) { return f(x) }
35. λ f . X f-bound => fn F(f) { return X(f) }
36. λ a . a         => fn A(a) { return a }
37. λ b . b         => fn B(b) { return b }
38. anon creates F, calls it with A, then calls the result with B
39.                  (F(A))(B)
40.
41. -- literally going in circles
42. F(A) -> X(A)
43. X(A) -> F(A)
44. ?
45.
46. -- trying to distinguish between defining functions and calling them
47. (
48.   def(
49.     def(λ F .
50.       def(λ X .
51.         call(F X)
52.       )
53.     )
54.     call(A)
55.   )
56.   call(B)
57. )
58.
59. -- still not realizing that "x" and "f" functions are more dynamic than I expected
60. anon1 = { return F(A) }
61. F = (F){ return (X){ F(X) } }
62. X = (X){ return F(X) }
63. A = (A){ return A }
64. B = (B){ return B }
65. anon1(B)
66.
67. F(B)
68. λ X . (F X)
69.
70. -- THIS is when I finally got the whole thing
71. ( ( (λ f . (λ x . (f x) ) ) (λ a . a) ) (λ b . b) )
72. B = fn(b) -> return b
73. A = fn(a) -> return a
74.
75. (λ f . (λ x . (f x) ) ) A B
76. F = fn(f) -> return (λ x . (f x) )
77. F(A)B
78.
79. λ x . (A x) B
80. X = fn(x) -> return A(x)
81. X(B) => A(B) => B
82.
83. λ x . f x  OR  λ x . (f x)  OR  "(x) -> f(x)"  OR  f
84. "functions are equal if they give the same results on all inputs"