@vaporeon_ @wallhackio the most impurrtant rule of the lambda calculus is the beta substitution rule, which is a fancy way of saying that when applying a function to an argument, you substitute all instances of the parameterized value with the argument. you know, like in a function

so, say, if you had the function λx.x + 2 (more or less equivalent to f(x) = x + 2, then if you applied the function to, say, 3 (which you might write like (λx.x + 2) 3, basically the same as writing f(3)), then you can beta-substitute and simplify the string to 3 + 2

there are, like, two other rules in the lambda calculus (one, eta-equivalence is just that λx.x + 2 is definitionally exactly equivalent to λy.y + 2)

i realize this is almost condescendingly simple when i explain it like this, but the absol-utely mindbending thing about the lambda calculus is that it’s already turing-complete. the expurressivity is way higher than you would ever expect; it’s thoroughly pawsible to define numbers and arithmetic opurrations in pure lambda calculus, fur example

hell, it’s pawsible to cheat your way into introducing something almost like general recursion into the language, using some rather clever hacking, without needing any change to the fundamental syntax at all

just about all functional purrogramming languages can be accurately described as having the semantics of a (typed) lambda calculus (which requires some extra rules, but purrevents all sorts of logical inconsistencies from being expurressible) with extra bells and whistles