why tho

why tho is a esolang created by User:Yayimhere and is inspired by Lambda calculus and Fractran.

How it works

The start of the program is a two lambda calculus expression (the first one is x_n, and the second one is x_m), each encased by square brackets.
The rest of the program consists of a list of lambda calculus expressions(all must be encased by normal brackets). Now the program sees if there is a lambda calculus function, f, such that when f is applied to x_n, it evaluates x_m.
If so, x_n will be set to f, and x_m will be set to x_n. Every iteration of this, it will print x_m, and f. 
if two functions are valid, it will set x_n to the first function with input as the second function
If f cannot be found, x_n will be added to the list, and x_m will be swapped with x_n. 
the program halts if xn=xm or xm=f. 
Why tho has input that can replace x_n, By simply replacing the expression with µ

simple example

heres a simple example:

[λx. x] [λx. y] (λx.(x y)) (λx. x) (λx. λx. y)
f = λx. λx. y
Beta reducing '(λx. x)' into '(λx. (λx. y))'
β > (λx. y)
xn is equal to (λx. y)
now:
xn = λx. x
xm = λx. λx. y
f cannot be found
add xm to the list:
(λx.(x y)) (λx. x) (λx. λx. y) (λx. λx. y)
do the swap:
xn = λx. λx. y
xm = λx. x
f cannot be found
...

the loop continues

computational class

ok. heres how to represent any expression(here the expression is A) in lambda calculus proving why tho TC. then the program would become:

[(λx.x)] [A] (λx.x A)

yea that simple. note that only the first iteration of why tho is considered for computation

see also

• Fractran
• Lambda calculus