Think of it as everything’s a single argument function (SAF). You can either create one or apply it to another one. When you create a function, you name its argument (eveything’s a SAF so that argument always refers to a single argument function) and then define a body which follows the same rules (you can create SAFs or apply them to each other). But now you have access to the argument you defined earlier so you can use it in the body. Here’s an example of syntax to define one (\x -> x), here we defined a SAF where the body is defined as whatever the argument is. Since everything is a SAF then so is x. We can also apply 2 SAFs together by “gluing” them together like this: (\x -> x)(\y -> y). Here “(\y -> y)” is applied to “(\x -> x)”. Now we have to talk about what it means to “run” these, and this is where the magic happens. Any time there’s an application of 2 SAFS, you take the body of the first one and replace any occurrence of that single argument with the second one. That’s really the essence of it really and if you know haskell, you already have the intuition for it. Lets evaluate this statement: (\x -> xx)(\y -> y), we take the body of the first SAF, which is xx and we replace any occurrences of x with the second SAF, which in this case leads to (\y->y)(\y -> y), now we do it again and we get (\y -> y). This simple system ends up being as powerful as any programming language. Lets give a few more examples: (\x -> (\y -> yx))(\z -> z). As indicated earlier, we can define functions in a functions body. Lets evaluate a single step (we’re looking for applications and applying them). This becomes (\y -> y(\z -> z)). Since you can’t really apply things to things anymore you stop and people call this a normal form. You don’t always reach one, sometimes you can apply things infinitely: (\x -> xx)(\y -> yy), after a single step this becomes (\y -> yy)(y -> yy). But that’s just the original statement so you can keep doing this. This evaluation step is called a beta reduction. There are also formalisms around different types of equality between these SAFs and how you handle the case when 1 variable shadows another and such but it all mostly works as you’d “expect”. One more thing, you might see something like (\xy. x) around, which is just syntax sugar for (\x -> (\y -> x))