44:["$","title",null,{"children":"Mindshift: Part 17 | Chris Whealy | Observable"}] 4c:T7b1,md`# Mindshift: Part 17 Republished on Dec 6th, 2018 # Passing Through Zero (and Surviving!) In the previous blog, we started preparing for the use of abstract functions that can represent signed integers. We did this by creating a PAIR out of a Boolean (to represent the sign) and a quantity function (to represent the magnitude). But no sooner had we done that, than we discovered our functions for finding the SUCCessor and PREDecessor of a quantity function are now broken. Previously, our ability to move up or down the number line stopped at zero. This is because we have defined counting to be the process of finding the n'th successor of zero. By this definition therefore, two actions impossible: 1. Finding the predecessor of ZERO 1. Defining some quantity function which, when passed to SUCC, returns ZERO Therefore, two arbitrary, special cases involving ZERO must now be handled. We must ensure that: 1. The PREDecessor of 0 is -1 1. The SUCCessor of -1 is 0 So to handle these conditions, we will first need a set of functions to perform various tests, such finding a NUMBER's sign and testing whether a NUMBER has an absolute value of 0 or 1. Currently, our existing SUCCessor and PREDecessor functions operate on unsigned quantity functions, and these will still be needed, but it is no longer safe to call them without first checking the magnitude of the quantity in question. The first thing we will do therefore is rename the existing SUCCessor and PREDecessor functions to SUCC_MAGNITUDE and PRED_MAGNITUDE. This is to indicate that these functions now operate on abstract quantity functions rather than signed NUMBERs. `4d:T38c2,lib = { // ******************************************************************** // Naming Conventions // // Functions with all uppercase names return abstract functions // // Functions with all lowercase names return native JavaScript data // types // ******************************************************************** // ******************************************************************** // 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) var magnitude = qtyFn => qtyFn(incr)(0) // ******************************************************************** // Functions that operate on pairs and return abstract functions // ******************************************************************** var TRUE = true_part => false_part => true_part var FALSE = true_part => false_part => false_part // HEAD and TAIL are synonyms for TRUE and FALSE var HEAD = pair => pair(TRUE) var TAIL = pair => pair(FALSE) var PAIR = val1 => val2 => fn => fn(val1)(val2) var EMPTY_LIST = PAIR(null)(null) var IS_EMPTY = pair => (HEAD(pair) === null && TAIL(pair) === null) ? TRUE : FALSE var IS_LAST = pair => IS_EMPTY(TAIL(pair)) // ******************************************************************** // Functions that operate on pairs and return JavaScript data types // ******************************************************************** var is_empty = pair => (HEAD(pair) === null) && (TAIL(pair) === null) var is_last = pair => is_empty(TAIL(pair)) var is_pos = number => to_boolean(IS_POS(number)) // ******************************************************************** // Define an abstract quantity function for unsigned ZERO and ONE // ******************************************************************** var ZERO_MAGNITUDE = transform => start_value => start_value var UNIT_MAGNITUDE = transform => start_value => transform(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_MAGNITUDE)(ZERO_MAGNITUDE)) (TRUE); // ******************************************************************** // Define a signed integer // ******************************************************************** var NUMBER = isPositive => qtyFn => PAIR(isPositive)(qtyFn) var ABS = number => TAIL(number) // ******************************************************************** // Arithmetic operations based on abstract quantity functions // ******************************************************************** var ADD = qtyFn1 => qtyFn2 => qtyFn1(SUCC)(qtyFn2); var MULTIPLY = qtyFn1 => qtyFn2 => qtyFn1(ADD(qtyFn2))(ZERO_MAGNITUDE); var POWER = qtyFn1 => qtyFn2 => qtyFn2(MULTIPLY(qtyFn1))(UNIT_MAGNITUDE); var SUBTRACT = qtyFn1 => qtyFn2 => qtyFn2(PRED)(qtyFn1); // ******************************************************************** // Boolean Operators // ******************************************************************** var NOT = bool => bool(FALSE)(TRUE); var AND = bool1 => bool2 => bool1(bool2)(FALSE); var OR = bool1 => bool2 => bool1(TRUE)(bool2); var XOR = bool1 => bool2 => bool1(NOT(bool2))(bool2); // ******************************************************************** // Predicate functions // ******************************************************************** var IS_POS = number => HEAD(number) var SIGN = IS_POS var IS_ZERO = number => ABS(number)(dont_care => FALSE)(TRUE) var IS_LTE = val1 => val2 => IS_ZERO(SUBTRACT(val1)(val2)); var IS_LT = val1 => val2 => NOT(IS_LTE(val2)(val1)); // ******************************************************************** // Combinators // ******************************************************************** var U = fn => fn(fn); var Y = (rec_fn => (gen_rec => U(gen_rec)) (gen_rec => rec_fn((n,a,b) => U(gen_rec)(n,a,b))) ) // ******************************************************************** // Create our own push function that returns the new array rather than // the index of the newly inserted item // ******************************************************************** var push = arr => val => (idx => arr)(arr.push(val)); // ******************************************************************** // Convert a character string to a list whilst preserving the // character order // ******************************************************************** var make_str2list = fn_next=> list => str => (str.length > 0) ? fn_next(PAIR(str.substr(-1))(list))(str.slice(0,-1)) : list; var str2list = str => Y(make_str2list)(EMPTY_LIST)(str); // ******************************************************************** // Convert a list back into a character string // ******************************************************************** var make_list2str = fn_next=> str => list => is_last(list) ? str.concat(HEAD(list)) : fn_next(str.concat(HEAD(list)))(TAIL(list)); var list2str = list => Y(make_list2str)("")(list); // ******************************************************************** // Convert a JavaScript array into a list // ******************************************************************** var make_array2list = fn_next=> list => array => (array.length === 0) ? list : fn_next(PAIR(array[array.length-1])(list)) (array.slice(0,-1)); var array2list = Y(make_array2list)(EMPTY_LIST); // ******************************************************************** // Convert a list to a JavaScript array // ******************************************************************** var make_list2array = fn_next=> arr => list => is_last(list) ? push(arr)(HEAD(list)) : fn_next(push(arr)(HEAD(list)))(TAIL(list)); var list2array = list => Y(make_list2array)([])(list); // ******************************************************************** // Reverse a list // ******************************************************************** var do_reverse = next_rev => new_list => old_list => IS_LAST(old_list) (PAIR(HEAD(old_list))(new_list)) (f => (next_rev(PAIR(HEAD(old_list))(new_list)) (TAIL(old_list))) (f)) var REVERSE = Y(do_reverse)(EMPTY_LIST) // ******************************************************************** // Generic MAP function // ******************************************************************** var make_map = next_map => new_list => fn => list => (list_acc => // Have we reached the end of the list? IS_LAST(list) // Yup, so reverse the items in the list and // we're done (f => REVERSE(list_acc)(f)) // Nope, so recursively call ourselves passing // in the list accumulator, the function being // applied and whatever is left in the current // list (f => (next_map(list_acc) (fn) (TAIL(list))) (f)) ) // Apply the mapping function to the first list item and // append the result to the start of the new list. This // value is then received as argument list_acc in the // function above (PAIR(fn(HEAD(list)))(new_list)) var MAP = Y(make_map)(EMPTY_LIST) // ******************************************************************** // Generic REDUCE function // ******************************************************************** var make_reduc = next_reduc => list => fn => acc => (new_acc => // Have we reached the end of the list? IS_LAST(list) // Yup, so simply return the accumulator (f => (new_acc)(f)) // Nope, so recursively call ourselves passing the // remainder of the list, the reduction function and the // new accumulator value (f => (next_reduc(TAIL(list)) (fn) (new_acc)) (f) ) ) // Calculate the new accumulator value. This value // appears as parameter new_acc in the above function (fn(HEAD(list))(acc)) // Create the REDUCE function using the Y-Combinator var REDUCE = Y(make_reduc) // Define a function to count the number of items in a list var COUNT = list => REDUCE(list) // The list being reduced (dont_care => acc => SUCC(acc)) // The reduction function (ZERO_MAGNITUDE) // The accumulator start value // ******************************************************************** // Convert a positive integer to its Church encoding // Null must be explicitly tested for to avoid disappearing down the // rabbit hole of infinite recursion. This is because JavaScript will // coerce null to be zero; therefore, the "(n-1)" part of the // expression "next_qty_fn(lib.SUCC(qty_fn))(n-1)" will become 0-1 // which then leads to infinite recursion. // // This behaviour does however result in mapping null to ZERO, which // might produce misleading results... // ******************************************************************** var do_qty_fn = next_qty_fn => qty_fn => n => (n === 0 || n === null) ? qty_fn : next_qty_fn(SUCC(qty_fn))(n-1) var TO_CHURCH = Y(do_qty_fn)(ZERO_MAGNITUDE) // Define a FACTORIAL function var FACTORIAL = list => REDUCE(list) // The list being reduced (val => acc => MULTIPLY(TO_CHURCH(val))(acc)) // The reduction function now using Church numerals (UNIT_MAGNITUDE) // The accumulator start value // Define a SUM function var SUM = list => REDUCE(list) // The list being reduced (val => acc => ADD(TO_CHURCH(val))(acc)) // The reduction function now using Church numerals (ZERO_MAGNITUDE) // The accumulator start value // Fold left is simply a synonym for REDUCE // Fold right is simply a fold left performed on the reversed list var FOLDL = REDUCE var FOLDR = list => REDUCE(REVERSE(list)) return { adder : adder , multiplier : multiplier , str_concatenate: str_concatenate , asPlusChar : str_concatenate('+') , incr : adder(1) , decr : adder(-1) , push : push , magnitude : magnitude , to_integer : to_integer , to_string : to_string , to_boolean : to_boolean , is_empty : is_empty , is_last : is_last , is_pos : is_pos , str2list : str2list , list2str : list2str , array2list : array2list , list2array : list2array , PAIR : PAIR , TRUE : TRUE , FALSE : FALSE , HEAD : HEAD , TAIL : TAIL , EMPTY_LIST : EMPTY_LIST , IS_EMPTY : IS_EMPTY , IS_LAST : IS_LAST , IS_POS : IS_POS , SUCC : SUCC , SUCC_PAIR : SUCC_PAIR , PRED : PRED , NUMBER : NUMBER , ABS : ABS , SIGN : SIGN , ZERO_MAGNITUDE : ZERO_MAGNITUDE , ADD : ADD , MULTIPLY : MULTIPLY , POWER : POWER , SUBTRACT : SUBTRACT , NOT : NOT , AND : AND , OR : OR , XOR : XOR , IS_ZERO : IS_ZERO , IS_LTE : IS_LTE , IS_LT : IS_LT , Y : Y , REVERSE : REVERSE , MAP : MAP , REDUCE : REDUCE , COUNT : COUNT , TO_CHURCH : TO_CHURCH , FACTORIAL : FACTORIAL , SUM : SUM , FOLDL : FOLDL , FOLDR : FOLDR } }4e:[] 48:{"id":"bb5567b309ca9d05","slug":"mindshift-part-17","title":"Mindshift: Part 17","thumbnail":"e29ba9c01c2c7287b41591bffb4185befac10b7b8807de0576dc87e68e89d306","access_level":"public","create_time":"$D2018-11-30T17:45:47.036Z","update_time":"$D2020-01-10T18:31:39.112Z","view_time":null,"first_public_time":"$D2018-12-06T20:39:25.920Z","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":203,"publish_version":203,"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 17","cells":[{"id":0,"value":"$4c","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":10,"value":"SUCC_MAGNITUDE = \n qtyFn =>\n transform =>\n start_value =>\n transform(qtyFn(transform)(start_value))\n","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":12,"value":"SUCC_MAGNITUDE_PAIR =\n pair =>\n lib.PAIR(pair(lib.FALSE))(SUCC_MAGNITUDE(pair(lib.FALSE)))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":14,"value":"PRED_MAGNITUDE =\n qtyFn =>\n qtyFn(SUCC_MAGNITUDE_PAIR)(lib.PAIR(lib.ZERO_MAGNITUDE)(lib.ZERO_MAGNITUDE))(lib.TRUE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":4,"value":"md`Remember that the PRED function (now renamed to PRED_MAGNITUDE) works out the predecessor of a quantity function by counting upwards from ZERO in PAIRs of (n-1, n). The predecessor of any number n is then the first quantity function in such a PAIR.\n\nNow that our existing SUCC and PRED functions have been renamed and we need to redefine some of our existing low-level functions and define some new functions specifically to handle signed integers:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":141,"value":"magnitude = qtyFn => qtyFn(lib.incr)(0)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":130,"value":"NUMBER = isPositive => qtyFn => lib.PAIR(isPositive)(qtyFn)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":113,"value":"IS_POS = number => lib.HEAD(number)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":116,"value":"// SIGN is a synonym for IS_POS \nSIGN = IS_POS","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":118,"value":"// Return the absoulte value of a signed integer. This function could also be called MAGNITUDE\nABS = number => lib.TAIL(number)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":114,"value":"ZERO_MAGNITUDE = transform => start_value => start_value","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":133,"value":"UNIT_MAGNITUDE = transform => start_value => transform(start_value)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":137,"value":"HAS_ZERO_MAGNITUDE = number => ABS(number)(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":139,"value":"HAS_UNIT_MAGNITUDE = number => magnitude(ABS(number)) === 1 ? lib.TRUE : lib.FALSE","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":143,"value":"IS_ZERO = number => HAS_ZERO_MAGNITUDE(number)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":145,"value":"IS_MINUS_ONE = number => lib.AND(lib.NOT(IS_POS(number)))\n (HAS_UNIT_MAGNITUDE(number))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":146,"value":"ZERO = NUMBER(lib.TRUE)(ZERO_MAGNITUDE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":109,"value":"md`Now we can define a new version of the SUCCessor function as follows:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":62,"value":"SUCC =\n number =>\n // Is the number positive?\n IS_POS(number)\n // Yup, so it must be >= 0, therefore return the positive\n // number created by calling SUCC_MAGNITUDE on the number's\n // absolute value\n (NUMBER(lib.TRUE)(SUCC_MAGNITUDE(ABS(number))))\n\n // Nope, so check for the special case of minus one\n (IS_MINUS_ONE(number)\n // Yup, so return value of ZERO\n (ZERO)\n\n // Nope, so the number must be <= -2\n // Therefore, return the negative number\n // created by calling PRED_MAGNITUDE on the\n // number's absolute value\n (NUMBER(lib.FALSE)(PRED_MAGNITUDE(ABS(number)))))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":67,"value":"md`The PRED function is defined in a similar manner:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":69,"value":"PRED =\n number =>\n // Check for the special case of zero\n (IS_ZERO(number)\n // Yup, so return MINUS_ONE\n (NUMBER(lib.FALSE)(UNIT_MAGNITUDE))\n\n // Is the number positive?\n (IS_POS(number)\n // Yup, so the number must be >= 1\n // Return the positive number created by calling\n // PRED_MAGNITUDE on the number's absolute value\n (NUMBER(lib.TRUE)(PRED_MAGNITUDE(ABS(number))))\n\n // Nope, so the number must be <= -1\n // Therefore, return the negative number\n // created by calling SUCC_MAGNITUDE on the\n // number's absolute value\n (NUMBER(lib.FALSE)(SUCC_MAGNITUDE(ABS(number))))))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":72,"value":"md`Good, so now we can redefine some of our counting numbers`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":154,"value":"PLUS_ONE = SUCC(ZERO)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":155,"value":"PLUS_TWO = SUCC(PLUS_ONE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":163,"value":"MINUS_ONE = PRED(ZERO)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":165,"value":"MINUS_TWO = PRED(MINUS_ONE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":171,"value":"MINUS_THREE = PRED(MINUS_TWO)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":158,"value":"md`Now we need to test these extended functions.\n\nIn the past, we have tested calculations involving abstract quantity functions by passing the result to the reification function to_integer that transforms an abstract quantity function into a JavaScript number.\n\nThe problem now is that since we have started working with functions that represent signed integers, our to_integer function will need to be adjusted to handle NUMBERs instead of abstract quantity functions.\n\nThis is done as follows:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":74,"value":"to_integer =\n number =>\n // Inner function\n (sign => mag => sign ? mag : mag * -1)\n // Extract the sign and absolute value from the NUMBER, then\n // reify these values and pass them to the inner function as the\n // sign and mag parameters \n (lib.to_boolean(lib.SIGN(number)))\n (lib.magnitude(lib.ABS(number)))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":80,"value":"md`Now we can finally start testing:`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":82,"value":"{\n // Check simple reification\n return {\n \"TWO_to_integer\" : to_integer(PLUS_TWO)\n , \"MINUS_THREE_to_integer\" : to_integer(MINUS_THREE)\n \n // Check SUCCessor passes up through ZERO without exploding\n , \"SUCC_MINUS_ONE\" : to_integer(SUCC(MINUS_ONE))\n , \"2nd_SUCC_MINUS_ONE\" : to_integer(SUCC(SUCC(MINUS_ONE)))\n , \"3rd_SUCC_MINUS_TWO\" : to_integer(SUCC(SUCC(SUCC(MINUS_TWO))))\n \n // Check PREDecessor passes down through ZERO without exploding\n , \"PRED_ONE\" : to_integer(PRED(PLUS_ONE))\n , \"2nd_PRED_ONE\" : to_integer(PRED(PRED(PLUS_ONE)))\n , \"3rd_PRED_TWO\" : to_integer(PRED(PRED(PRED(PLUS_TWO))))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":180,"value":"md`Good, that works nicely!\n\nNow we are in a position to extend the arithmetic functions of ADD, SUBTRACT and MULTIPLY to handle these abstract signed integer functions.\n\nChris W\n\n\n\n \n

\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":17,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W4e","stdlib":"1"}} 24:null