-- taking notes while examining the structure, this is when I finally figured out how "two arguments were passed"
-- through the "f" and "x" functions
call a function(1)
f1()
that function is the result of another(2) function being called with a third(B) function
f1 = f2(B)
the second(2) function returns function(f) called with a forth(A) function
f2 = return ff(A)
function(x) is defined by a call to its bound function(F)
fx = F(x)
function(f) binds the passed function and returns function(x)
ff = fx(F)
finally, function(f) is called with function(A) (SEE ABOVE)
f1() -> f2(B) -> ff(A)(B) ->
fx(A)(B) -> A(B) -> B
ff(A) really means F = A & call fx(B)
-- nesting to try to understand it better
(1
(2
(λ f .
(λ x .
(f x)
)
)
(λ a . a)
)
(λ b . b)
)
-- attempting a syntax that I understand better
λ x . (f x) => fn X(x) { return f(x) }
λ f . X f-bound => fn F(f) { return X(f) }
λ a . a => fn A(a) { return a }
λ b . b => fn B(b) { return b }
anon creates F, calls it with A, then calls the result with B
(F(A))(B)
-- literally going in circles
F(A) -> X(A)
X(A) -> F(A)
?
-- trying to distinguish between defining functions and calling them
(
def(
def(λ F .
def(λ X .
call(F X)
)
)
call(A)
)
call(B)
)
-- still not realizing that "x" and "f" functions are more dynamic than I expected
anon1 = { return F(A) }
F = (F){ return (X){ F(X) } }
X = (X){ return F(X) }
A = (A){ return A }
B = (B){ return B }
anon1(B)
F(B)
λ X . (F X)
-- THIS is when I finally got the whole thing
( ( (λ f . (λ x . (f x) ) ) (λ a . a) ) (λ b . b) )
B = fn(b) -> return b
A = fn(a) -> return a
(λ f . (λ x . (f x) ) ) A B
F = fn(f) -> return (λ x . (f x) )
F(A)B
λ x . (A x) B
X = fn(x) -> return A(x)
X(B) => A(B) => B
λ x . f x OR λ x . (f x) OR "(x) -> f(x)" OR f
"functions are equal if they give the same results on all inputs"
Comments
0 B
|0 👍
/0 👎
0 B
|👍
/👎