44:["$","title",null,{"children":"Mindshift: Part 16 | Chris Whealy | Observable"}] 4c:T7d7,md`# Mindshift: Part 16 Republished on Oct 6th, 2018 # Preparing For Negative Numbers So far in this blog series, our ability to count has been restricted to handling only positive integers. It goes therefore that this restriction seriously limits our computational abilities. So its time to look at extending our counting system to include negative integers. In order to perform this extension, we must first have a clear understanding about how our current counting system works. ## Recap - Understanding How We've Been Counting So Far Our method of representing the counting numbers is based on defining the ***behaviour*** of the computation needed to derive such a quantity. In general, we define a function that when executed, starts at zero and invokes some transformation function n times. In the case of deriving the counting numbers, we start with ZERO and apply the SUCCessor transformation function n times, where n is the desired counting number. The name I have been using for the resulting function is an ***Abstract Quantity Function***. Such functions are ***Abstract*** in the sense that they do not represent any concrete value, such as a specific counting number; but instead, they represent the ***behaviour*** of the computation needed to derive that value. And they are also ***Quantity Functions*** in the sense that the transformation function is applied to the starting value a certain number of times, and this number (or quantity) is hard-coded within the function. Abstract quantity functions are sufficiently generic that they can be applied to many different situations - not simply the generation of counting numbers. This is a key point to understand because we have been working with functions that separate the ***behaviour*** of a computation from the specific details of performing some instance of that computation. This is abstraction - functional style. ## Starting From Nothing `4d:Tb65,md ` But look closely at what is happening here: **Q:** How many parameters does the SUCCessor function require?
**A:** Three: A quantity function, a transformation function and a starting value **Q:** How many parameters are we passing the SUCCessor function at the time we generate ONE or TWO or THREE etc?
**A:** Only one - just the preceding quantity function Hmmm, so how does this work? The point is that when we call a curried function such as SUCC, we are not required to supply ***all*** of its arguments. (If this statement makes little or no sense to you, then please read [part 4](https://beta.observablehq.com/@chriswhealy/mindshift-part-4) of this blog series.) Any time we supply some (but not all) of the required arguments to a curried function, what we get back is a partial function within which the values of the supplied arguments have been hard-coded, and the remaining arguments are the partial function's arguments. Each time we invoke function SUCC, we supply the preceding quantity function, but we deliberately omit the remaining two arguments; I.E. the transformation function and the starting value. Therefore, the functions ONE, TWO, and THREE etc. represent only the ***behaviour*** of the computations in which some (as yet undefined) transformation function will be applied to some (as yet undefined) starting value. ## Are These Functions Abstract Or Real? Yes... What makes these abstract quantity functions so versatile is that the fact that they represent the ***behaviour*** of a computation, not the the specific result created by performing that computation. This means such functions can be used in one of two ways: 1. If you supply them with other abstract quantity functions, they will generate the behaviour needed to perform some other computation 1. If you supply them with some reification function, they will generate a concrete value such as an integer or a string It all depends on what you want to do. When working with abstract quantity functions such as these, ask yourself the following questions: **Q1:** Do I want to build a function that represents the ***behaviour*** (or structure) of some computation? **A1:** Yes? Then I can construct this computation using other abstract functions as parameters. **Q2:** Or do I want to reify an abstract quantity function? **A2:** Yes? Then I should pass the abstract quantity function both a suitable transformation function ***and*** a suitable starting value. The reification function will then be invoked according to the behaviour described within the abstract quantity function, and the result will be some native data type such as a string, or an integer, or perhaps a JavaScript object. For instance: `4e:T532,{ // Define the increment and decrement reification functions var adder = val1 => val2 => val1 + val2; var incr = adder(1); var decr = adder(-1); // Starting from ZERO and SUCCESSOR, define some abstract quantity functions var ZERO = transform => start_value => start_value; var SUCC = qtyFn => transform => start_value => transform(qtyFn(transform)(start_value)); var ONE = SUCC(ZERO); var TWO = SUCC(ONE); var THREE = SUCC(TWO); // Using the abstract quantity function TWO, apply the SUCC function twice to a starting value of THREE // In other words, this operation represents the behaviour of performing the ADD operation 2 + 3 // The resulting function encodes the behaviour needed to generate the value FIVE var FIVE = TWO(SUCC)(THREE); return { // Just to prove that the behaviour of our abstract quantity functions is correct, // reify these functions by passing the transformation function "incr" and a starting value of 0. // This causes the relevant counting numbers to be generated reify_TWO : TWO(incr)(0) , reify_THREE : THREE(incr)(0) , reify_FIVE : FIVE(incr)(0) // Apply the decr function three times to a starting value of 7 // In other words, subtract 3 from 7 , reify_seven_minus_three : THREE(decr)(7) } }4f:T4e0,md` ## How Big Is A Quantity Function? Often it is useful to know exactly how many times an abstract quantity function will apply its transformation function to the starting value. The simplest way to discover this is to pass the quantity function a starting value of integer 0 and a transformation function that increments that value once for each invocation. But isn't that how we generate the counting numbers? Exactly! But since we're looking at the counting numbers through the lens of abstract quantity functions, it would be more helpful for us to think of the reified counting number as a side-effect, or consequence of the quantity function's ***magnitude***. So now we can create simple a function called magnitude that takes an abstract quantity function as its only parameter, and returns that function's magnitude. In other words, it returns an integer showing how many times the transformation function is called. ***IMPORTANT*** Remember how our function naming convention works here: if a function name is in ALL_CAPS, then it returns some type of abstract quantity function, and if the function name is all lowercase, then that function returns a JavaScript data type `50:T5d0,md` ## Teeny Weeny Problem... Zero So we now have a means for representing signed integers as abstract functions. In addition to this, we also have a means for testing the sign and obtaining the absolute value of such a signed integer. But what about zero? Strictly speaking, zero is neither positive nor negative. It sits at the centre of the number line and joins the positive and negative halves together - without being a member of either half! > As a rather awkward aside however, it is worth mentioning at this point that the IEEE 754 standard for defining Floating Point calculations requires the use of signed zero. > > Consequently, we now have the odd situation that

1 / -0 = -Infinity

and

1 / 0 = +Infinity

> > And yet -0 === +0 returns true Anyway, in our little scheme of representing signed integers, we have represented the sign as a binary value and arbitrarily followed the convention that zero has a positive sign value. So now we can redefine ZERO by forming a PAIR from the abstract Boolean function TRUE and some representation of zero. But we can't use the previous definition of ZERO because that's what we're redefining here. What we need is a representation of the absolute value zero, rather than the signed value.`51:T390f,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); // ******************************************************************** // 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)); // ******************************************************************** // 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); var ELEVEN = SUCC(TEN); var TWELVE = SUCC(ELEVEN); // ******************************************************************** // 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); // ******************************************************************** // 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_ZERO = qtyFn => qtyFn(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) // 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) // 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 (ONE) // 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) // 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 , to_integer : to_integer , to_string : to_string , to_boolean : to_boolean , is_empty : is_empty , is_last : is_last , 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 , SUCC : SUCC , SUCC_PAIR : SUCC_PAIR , PRED : PRED , ZERO : ZERO , ONE : ONE , TWO : TWO , THREE : THREE , FOUR : FOUR , FIVE : FIVE , SIX : SIX , SEVEN : SEVEN , EIGHT : EIGHT , NINE : NINE , TEN : TEN , ELEVEN : ELEVEN , TWELVE : TWELVE , 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 } }52:[] 48:{"id":"703ba1520aabece6","slug":"mindshift-part-16","title":"Mindshift: Part 16","thumbnail":"003e50cd1bca3fe6fce4e611a488e7615c93b4f24d50ad3b3c1f3cd1fc980edf","access_level":"public","create_time":"$D2018-10-06T06:05:34.790Z","update_time":"$D2020-01-10T18:31:09.191Z","view_time":null,"first_public_time":"$D2018-10-07T13:28:08.799Z","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":230,"publish_version":230,"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 16","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":"{\n var ZERO = transform => start_value => start_value\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":11,"value":"{\n var ONE = transform => start_value => 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":17,"value":"md`\nThe function ZERO describes a computation in which some transformation function is applied ***zero times*** to the starting value. We can tell the transformation function is applied zero times simply by looking at the function definition - the function supplied as argument transform is simply ignored.\n\nSimilarly, the function ONE describes a computation in which the transformation function is applied _**once**_ to the starting value.\n\nWe could continue in this same vein and define a function TWO as follows:\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":24,"value":"{\n var TWO = transform => start_value => transform(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":22,"value":"md`\nBut as you can imagine, having to write functions in which you hard-code the required number of nested calls to transform will rapidly become impractical.\n\nHowever, using our definition of the computation for ZERO, we can create a function that calculates the SUCCessor of the previous quantity function.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":30,"value":"{\n var ZERO = transform => start_value => start_value;\n var SUCC =\n qtyFn =>\n transform =>\n start_value => 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":27,"value":"md`\nThe beauty of the SUCCessor approach is that we do not need to hard-code some predetermined number of nested calls to the transform function. SUCC does that for us.\n\nHence we can create any quantity function simply by generating the SUCCessor of the previous one. Hence:\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":39,"value":"{\n var ZERO = transform => start_value => start_value;\n var SUCC =\n qtyFn =>\n transform =>\n start_value => transform(qtyFn(transform)(start_value));\n\n var ONE = SUCC(ZERO);\n var TWO = SUCC(ONE);\n var THREE = SUCC(TWO);\n var FOUR = SUCC(THREE);\n var FIVE = SUCC(FOUR);\n var SIX = SUCC(FIVE); \n var SEVEN = SUCC(SIX); \n var EIGHT = SUCC(SEVEN); \n var NINE = SUCC(EIGHT); \n var TEN = SUCC(NINE);\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":37,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":56,"value":"$4e","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":66,"value":"$4f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":69,"value":"// How many times will a quantity function call its transformation function?\nmagnitude = 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":61,"value":"{\n // What's the magnitude of these abstract quantity functions?\n return {\n magnitude_of_ZERO : magnitude(lib.ZERO)\n , magnitude_of_THREE : magnitude(lib.THREE)\n , magnitude_of_third_SUCC_of_TWO : magnitude(lib.TWO(lib.SUCC)(lib.THREE))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":79,"value":"md`\n## So How Would We Represent A Negative Number?\n\nSince we already have a perfectly good (albeit abstract) mechanism for representing the counting integers, all we lack is the ability to store a plus or minus sign along with that quantity.\n\nSo, if we have a quick rummage around in our existing toolbox of functions, we'll find we already have the tools needed to build a solution.\n\nWe can represent the plus or minus sign with a Boolean TRUE or FALSE, and then we can create a PAIR from an abstract Boolean and an abstract quantity function.\n\nIn other words, we can use the PAIR function to join together a sign and a magnitude, thus forming a signed integer.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":75,"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":83,"value":"md`\nSo positive and negative numbers can be created like this:\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":85,"value":"PLUS_ONE = NUMBER(lib.TRUE)(lib.ONE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":93,"value":"MINUS_ONE = NUMBER(lib.FALSE)(lib.ONE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":110,"value":"md`\nSo now we can find out whether a number is positive or negative by creating two functions, is_pos and IS_POS. (These functions could just as easily be called something like SIGN).\n\nIn keeping with our naming convention, the lowercase function is_pos returns a native JavaScript data type, and the uppercase function IS_POS returns an abstract Boolean function.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":102,"value":"is_pos = number => to_boolean(IS_POS(number))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":97,"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":114,"value":"md`We will also need to create a to_boolean function to reify our abstract TRUE and FALSE functions.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":96,"value":"to_boolean = bool => bool(true)(false)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":122,"value":"md`\nNow we can determine the sign of an abstract NUMBER using both the abstract IS_POS function and the reifying is_pos function\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":104,"value":"{\n return {\n abstract_sign_ONE : IS_POS(PLUS_ONE)\n , abstract_sign_MINUS_ONE : IS_POS(MINUS_ONE)\n\n , reified_sign_ONE : is_pos(PLUS_ONE)\n , reified_sign_MINUS_ONE : is_pos(MINUS_ONE)\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":49,"value":"md`\nIf we can test the sign that easily, we can also easily test for the NUMBER's magnitude. Here we could apply our magnitude function to the quantity function returned by passing the NUMBER to TAIL. However, it would be better if we were a little more rigorous about our terminology.\n\nThe value of a number without its sign is more correctly referred to as its ***absolute*** value; so we'll create some functions called abs and ABS as per our naming convention.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":127,"value":"ABS = 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":128,"value":"abs = number => magnitude(ABS(number))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":135,"value":"{\n return {\n abstract_abs_of_ONE : ABS(PLUS_ONE)\n , abstract_abs_of_MINUS_ONE : ABS(MINUS_ONE)\n\n , reified_abs_of_ONE : abs(PLUS_ONE)\n , reified_abs_of_MINUS_ONE : abs(MINUS_ONE)\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":206,"value":"$50","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":142,"value":"_ZERO = NUMBER(lib.TRUE)(/* Hmmm, what value goes here? */)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":151,"value":"md`\nFor this, we will therefore rename our old, unsigned definition of ZERO to be ZERO_MAGNITUDE.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":148,"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":156,"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":139,"value":"md`\nSo whilst this is rather arbitrary, it will serve as a workable representation of ZERO.\n\nHowever, we should now realise the consequences of what we've just done. By changing the definition of ZERO from unsigned to signed, we've just broken our SUCCessor and PREDecessor functions.\n\nBoo hoo!\n\nSo in the next blog, we'll look at how the SUCCessor and PREDecessor functions need to change in order to handle signed integers instead of unsigned integers.\n\nChris W\n\n\n\n \n

Previous Blog

Next Blog

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