Some booly functions

(2017-07-27. Index.)

This post is part of a list: Some lambda-notes
Next thing: Pairs
Previous thing: What do the lambdas?

Bit of prelude, first. Some stuff from an earlier numbery post:

(And in the earlier post we said something like: The number n is a function that, if given two arguments, applies the first argument n times to the second. The +-function takes the numbers a and b as arguments and gives back a new λf.λx.-function that applies fa times” to the result of applying fb times” to x.)

We can do like multiuplication as well, before moving on. Multiplication is like addition, just more. We will make a function that, if given the numbers a and b as arguments, will like, start with the number zero, and add ab times” to it:

Soo. We have several numbers and also a couple of ways to make more numbers. So we pretty much have business: We can decide that one of the numbers is the number of monies and another one is the number of products. If we also have booleans we can do business logic.

Booleans are used for if-then-else. We have a stuff we maybe wanna do and another stuff we maybe wanna do instead, and we use a boolean to pick one of the stuffs. So, we would like to have a true-value and a false-value, and we wanna set things up so that something like if true stuff otherstuff will evaluate to stuff, and something like if false stuff otherstuff will evalute to otherstuff.

We will make the two boolean values be functions. (A reasonably easy choice, so long as we can only make functions in our language.) true will, if given two arguments, return the first one. false, if given two arguments, will return the second one.

Okay so it looks like true stuff otherstuff evaluates to stuff just fine on it’s own, and false stuff otherstuff evaluates to otherstuff, and we don’t really need if. But like if we want an if we can have one. It can take a boolean as its first arguments and then two more arguments, and then like, just, hand those two last arguments over to the boolean.

Should get same results as with just the booleans. (And if we want to, we can redefine if to be the identity function, λx.x. Will work fine. The if true part of if true stuff otherstuff wil evaluate to true. So we get true stuff otherstuff, which we already know that works.)

Okay, some boolean logic bits:

• not takes one boolean b. If b is true, not returns false. If b is false, not returns true.
• and takes two booleans a and b. If a is true, and returns b. If a is false, and returns false.
• or takes two booleans a and b. If a is true, or returns true. If a is false, or returns b.

We’ll do some boolean stuff with numbers. We can check if a number is zero by giving it two arguments. The first argument is a function that always returns false: λ_.false. If the number is not zero this function will be applied to something and we’ll get false back. The second argument is true. If the number is zero this true will be returned, without any applying of the λ_.false-function.

Good. Now we can do everyday business logic things. Like you know when boss is like hey we need a program that checks if the number of monies times the number of products is zero and if it is zero we should add five to the number of monies and if it is not zero we should multiply the number of products by 2. And like, no problem.