44:["$","title",null,{"children":"Mindshift: Part 8 | Chris Whealy | Observable"}] 4c:T79c,md`Notice how the transform function is used inside the ZERO function – it isn’t. It’s completely ignored; all that happens inside ZERO is that the second parameter (start_value) is returned unmodified. >## Aside >Let’s hold the definition of ZERO up against the definition of another function we’ve seen already – FALSE. >


// Comparing ZERO and FALSE

ZERO  = transform => start_value => start_value

FALSE = true_part => false_part   => false_part

>Ok, the parameter names are different, but their functionality is identical! Both ZERO and FALSE perform no processing (in the sense of performing some calculation) and brainlessly return their second parameter. >This now provides us with a (possibly unexpected) way to demonstrate that it is far more than simply computing convention to evaluate Boolean **false** to zero – they are in fact functionally indistinguishable. The only circumstance under which a quantity function will ignore its transformation function is when it has a magnitude of zero. The flip-side of this that for any quantity function having a non-zero magnitude, the transformation function will always be called ***at least once***. Therefore, this behaviour can be used to get a quantity function to reveal whether or not it has zero magnitude. We will create a special transformation function that, if called, will ***always*** return FALSE. Now, when we pass the quantity function both this special transformation function and a starting value of TRUE, we know that if the quantity function has a magnitude of zero, the transformation function will be ignored and we'll get back the value TRUE. For any other magnitude, the transformation function will be called at least once, thus guaranteeing a return value of FALSE. `4d:T68f,md`Now that we have these tools available to us, we can start to look at arithmetic operations such as division and modulus. However, what makes these operations harder to implement is that they need to perform the SUBTRACT operation an unknown number of times. This requires the use of recursion. Here, we run up against another problem. Any recursively defined function must be able to make reference to itself; but if we create a DIV function that refers to itself directly by name, then we have broken our rule disallowing the use of external names for self-reference. I know I’ve been cheating slightly by assigning names such as TRUE, ZERO and MULTIPLY to our function definitions, but this is to account for our severely limited human ability to interpret long expressions. Really, names such as ZERO and MULTIPLY behave as macros that are substituted at runtime for the functions they represent. At first, you might think this arbitrary restriction requires us to perform some pointless mental gymnastics simply to overcome our own self-imposed hurdles. Whilst this might be true from one particular perspective, from the wider perspective of understanding the nature of computation, overcoming these hurdles leads us to an understanding of a very profound construct in functional programming, known as the "Fixed Point" or Y-combinator. Chris W

Next Blog

`4e:T1259,lib = { // ******************************************************************** // Generic operations // ******************************************************************** var adder = val1 => val2 => val1 + val2; var multiplier = p => q => q*p; var str_concatenate = char => acc => acc.concat(char); var asPlusChar = str_concatenate('+'); // The increment and decrement functions can now be created var incr = adder(1); var decr = adder(-1); // Use the multiplier function to create partial functions that // double, triple and quadruple their subsequent operand var double = multiplier(2); // -> double = q => q*p (p = 2) var triple = multiplier(3); // -> triple = q => q*p (p = 3) var quadruple = multiplier(4); // -> quadruple = q => q*p (p = 4) var add5 = adder(5); // -> add5 = q => q+5 // ******************************************************************** // Function Composition // ******************************************************************** var compose = fn1 => fn2 => val => fn2(fn1(val)); // Now we can "compose" double and add5 into a single function var doubleAndAdd5 = compose(double)(add5); // ******************************************************************** // Reification functions // ******************************************************************** var to_integer = qtyFn => qtyFn(incr)(0); var to_string = qtyFn => qtyFn(asPlusChar)(''); var to_boolean = fn => fn(true)(false); // ******************************************************************** // Functions that operate on pairs // ******************************************************************** var PAIR = val1 => val2 => fn => fn(val1)(val2); var TRUE = true_part => false_part => true_part; var FALSE = true_part => false_part => false_part; var HEAD = pair => pair(TRUE); var TAIL = pair => pair(FALSE); // ******************************************************************** // Define an abstract quantity function for ZERO. // ******************************************************************** var ZERO = transform => start_value => start_value; // ******************************************************************** // Successor and predecessor functions // ******************************************************************** var SUCC = qtyFn => transform => start_value => transform(qtyFn(transform)(start_value)); var SUCC_PAIR = pair => PAIR(pair(FALSE))(SUCC(pair(FALSE))); var PRED = qtyFn => qtyFn(SUCC_PAIR)(PAIR(ZERO)(ZERO))(TRUE); // ******************************************************************** // Now each quantity function can be defined simply as the successor // of the quantity function before it. // ******************************************************************** var ONE = SUCC(ZERO); var TWO = SUCC(ONE); var THREE = SUCC(TWO); var FOUR = SUCC(THREE); var FIVE = SUCC(FOUR); var SIX = SUCC(FIVE); var SEVEN = SUCC(SIX); var EIGHT = SUCC(SEVEN); var NINE = SUCC(EIGHT); var TEN = SUCC(NINE); // ******************************************************************** // Arithmetic operations based on abstract quantity functions // ******************************************************************** var ADD = qtyFn1 => qtyFn2 => qtyFn1(SUCC)(qtyFn2); var MULTIPLY = qtyFn1 => qtyFn2 => qtyFn1(ADD(qtyFn2))(ZERO); var POWER = qtyFn1 => qtyFn2 => qtyFn2(MULTIPLY(qtyFn1))(ONE); var SUBTRACT = qtyFn1 => qtyFn2 => qtyFn2(PRED)(qtyFn1); return { adder : adder, multiplier : multiplier, str_concatenate: str_concatenate, asPlusChar : str_concatenate('+'), incr : adder(1), decr : adder(-1), to_integer : to_integer, to_string : to_string, to_boolean : to_boolean, PAIR : PAIR, TRUE : TRUE, FALSE : FALSE, HEAD : HEAD, TAIL : TAIL, ZERO : ZERO, SUCC : SUCC, SUCC_PAIR : SUCC_PAIR, PRED : PRED, ONE : SUCC(ZERO), TWO : SUCC(ONE), THREE : SUCC(TWO), FOUR : SUCC(THREE), FIVE : SUCC(FOUR), SIX : SUCC(FIVE), SEVEN : SUCC(SIX), EIGHT : SUCC(SEVEN), NINE : SUCC(EIGHT), TEN : SUCC(NINE), ADD : ADD, MULTIPLY : MULTIPLY, POWER : POWER, SUBTRACT : SUBTRACT } }4f:[] 48:{"id":"71a56d31a6ecb23e","slug":"mindshift-part-8","title":"Mindshift: Part 8","thumbnail":"eae450e216020a726cac6ab727f3e936f3fa8bbe196a7e2d938f333cfda7ea8f","access_level":"public","create_time":"$D2018-02-02T18:01:37.685Z","update_time":"$D2020-01-10T18:24:48.761Z","view_time":null,"first_public_time":"$D2018-02-03T16:45:33.669Z","has_unpublished_edits":null,"fork":false,"stars":0,"starred":false,"owner":{"type":"team","id":"224d52e60cffa1e1","login":"chriswhealy","name":"Chris Whealy","avatar_url":"https://avatars-next.observableusercontent.com/fe4f3dea84e903c1f07bbfa1cc8292304033a736d3ab9d0e5c009d1340bfefb8","tier":"starter_2024","bio":"","followed_by_you":false,"follows_you":false},"version":158,"publish_version":158,"role":null,"authored":false,"authors":[{"type":"individual","id":"c2414676c206a65f","login":"chriswhealy","name":"Chris Whealy","avatar_url":"https://avatars-next.observableusercontent.com/fe4f3dea84e903c1f07bbfa1cc8292304033a736d3ab9d0e5c009d1340bfefb8","tier":null,"bio":"","followed_by_you":false,"follows_you":false}],"members":[{"type":"individual","id":"c2414676c206a65f","login":"chriswhealy","name":"Chris Whealy","avatar_url":"https://avatars-next.observableusercontent.com/fe4f3dea84e903c1f07bbfa1cc8292304033a736d3ab9d0e5c009d1340bfefb8","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Mindshift: Part 8","cells":[{"id":0,"value":"md`# Mindshift: Part 8\n\nRepublished on Feb 3rd, 2018\n\n# Using Minimal Functions To Build Predicates And Boolean Operators\n\nIn part 7, we looked at how subtraction can be performed when our counting system only allows us to count upwards from zero.\n\nNow we need to develop some predicate functions to perform various equivalence tests, and from these, then build up a wider range of functional tools.\n\n## There’s Nothing There - Or Is There?\nIt would be pretty handy if we could determine whether a quantity function is ZERO or not. To put that in fancier language, *how can we tell whether or not a quantity function has zero magnitude*?\n\nLets remind ourselves of the basic definition of ZERO and ONE (and for the time being, ignoring the use of the SUCCessor function).\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":26,"value":"$4c","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":24,"value":"// Define an IS_ZERO function\nIS_ZERO = qtyFn => qtyFn(dont_care => lib.FALSE)(lib.TRUE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":31,"value":"lib.to_boolean(IS_ZERO(lib.ONE))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":40,"value":"md`So now that we can determine whether a quantity function has a magnitude of zero, we can now define the “less than or equal to” predicate.\n\n\n\n## Less Is More (Than a Negative Number)\n\nYou might recall from the previous blog that our counting system cannot handle negative numbers. This means that we will get odd results such as 5 - 8 = 0 instead of the expected -3.\n\nApart from limiting all our calculations to give positive answers, this is in fact a useful feature that allows us to check whether one number is greater than another number.\n\nAll we need to do is subtract one number from the other, then pass the result to our new IS_ZERO function. And there you have it, a definition for the “_less than or equal to_” predicate.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":42,"value":"// Define an IS_LessThanEqual function\nIS_LTE = val1 => val2 => IS_ZERO(lib.SUBTRACT(val1)(val2))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":79,"value":"md`## Boolean Operators\n\nUsing the Boolean values of TRUE and FALSE, the normal Boolean operators of NOT, AND, OR and XOR can be defined.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":81,"value":"AND = bool1 => bool2 => bool1(bool2)(lib.FALSE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":84,"value":"OR = bool1 => bool2 => bool1(lib.TRUE)(bool2)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":87,"value":"NOT = bool => bool(lib.FALSE)(lib.TRUE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":91,"value":"XOR = bool1 => bool2 => bool1(NOT(bool2))(bool2)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":94,"value":"md`So let's chack that these functions gives us the expected results:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":131,"value":"{\n // Check the NOT function\n return {\n NOT_false : lib.to_boolean(NOT(lib.FALSE)),\n NOT_true : lib.to_boolean(NOT(lib.TRUE))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":96,"value":"{\n // Check the AND function\n return {\n false_AND_false : lib.to_boolean(AND(lib.FALSE)(lib.FALSE)),\n true_AND_false : lib.to_boolean(AND(lib.TRUE)(lib.FALSE)),\n false_AND_true : lib.to_boolean(AND(lib.FALSE)(lib.TRUE)),\n true_AND_true : lib.to_boolean(AND(lib.TRUE)(lib.TRUE))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":128,"value":"{\n // Check the OR function\n return {\n false_OR_false : lib.to_boolean(OR(lib.FALSE)(lib.FALSE)),\n true_OR_false : lib.to_boolean(OR(lib.TRUE)(lib.FALSE)),\n false_OR_true : lib.to_boolean(OR(lib.FALSE)(lib.TRUE)),\n true_OR_true : lib.to_boolean(OR(lib.TRUE)(lib.TRUE))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":136,"value":"{\n // Check the XOR function\n return {\n false_XOR_false : lib.to_boolean(XOR(lib.FALSE)(lib.FALSE)),\n true_XOR_false : lib.to_boolean(XOR(lib.TRUE)(lib.FALSE)),\n false_XOR_true : lib.to_boolean(XOR(lib.FALSE)(lib.TRUE)),\n true_XOR_true : lib.to_boolean(XOR(lib.TRUE)(lib.TRUE))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":139,"value":"md`Now that we have a NOT and a IS_LTE operator, it is quite straight-forward to adapt this to create a “less than” operator.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":141,"value":"IS_LT = val1 => val2 => NOT(IS_LTE(val2)(val1))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":144,"value":"// Check that our IS_LT function behaves correctly\n{\n return {\n is_5_LT_8: lib.to_boolean(IS_LT(lib.FIVE)(lib.EIGHT)),\n is_7_LT_4: lib.to_boolean(IS_LT(lib.SEVEN)(lib.FOUR)),\n is_6_LT_6: lib.to_boolean(IS_LT(lib.SIX)(lib.SIX))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":150,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":101,"value":"$4e","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W4f","stdlib":"1"}} 24:null