44:["$","title",null,{"children":"Mindshift: Part 12 | Chris Whealy | Observable"}] 4c:T438,{ // Use the Y-Combinator to perform recursive subtraction var do_div = div_next => count => remainder => divisor => // Should we continue with recursion? (divisor <= remainder) // Yup, call div_next with an incremented counter, a new remainder // (of the divisor subtracted from the old remainder) and the divisor ? div_next(count + 1) (remainder - divisor) (divisor) // Nope, we've reached the end so return an object containing the // the counter (now the quotient) and whatever is left over in the // remainder : { quotient : count , remainder: remainder} // Now create the "div" function using the Y-Combinator and as we did // before, also supply the initial quotient value var div = Y(do_div)(0); // Return the answers to 10/3, 12/6 and 5/9 return { "10_divided_by_3" : div(10)(3) , "12_divided_by_2" : div(12)(6) , "5_divided_by_9" : div(5)(9) } }4d:T66e,md`Ok, that was easy enough. ### Replace The Integer Values With Abstract Quantity Functions Now we need to adapt the do_div function so that instead of working with integers, it works with abstract quantity functions. To start with, the easiest value to change is the quotient counter called count. If you look at the code, the only thing we actually do with the count parameter is to add one to it. So this is easy enough to adapt. However, if we are now treating parameter count as a quantity function, we can't simply perform the arithmetic operation ***+ 1*** on it anymore. But, we do have a function that can work out the successor of any quantity function. When the resulting quantity function is finally reified using the incr function and a starting value of 0, it will yield the correct counter value. However, we need to be careful. Since count is now an abstract quantity function and not an integer, it wouldn't be very user friendly if we a returned an object containing a mixture of property types: an abstract quantity function and an integer. Therefore, we will convert the count parameter back to an integer before returning its value. (See the [Mindshift: Part 5](https://beta.observablehq.com/@chriswhealy/mindshift-blog-part-5) blog for details of how to reify an abstract quantity function.) Also, to keep our naming convention consistent, we should rename div to DIV to indicate that it now works with quantity functions rather than integers. So our code is adapted as follows: `4e:T4a0,{ // Treat parameter count as a quantity function instead of an integer var do_div = div_next => count => remainder => divisor => // Should we continue with recursion? (divisor <= remainder) // Yup, call div_next with an incremented counter, a new remainder // (of the divisor subtracted from the old remainder) and the divisor ? div_next(lib.SUCC(count)) (remainder - divisor) (divisor) // Nope, we've reached the end so return an object containing the // the counter (now the quotient) and whatever is left over in the // remainder : { quotient : lib.to_integer(count) , remainder: remainder} // Now that count is an abstract quantity function and not an integer, // we must pass the quantity function ZERO as the start value for the // quotient counter instead of integer 0 var DIV = Y(do_div)(lib.ZERO); // Return the answers to 10/3, 12/6 and 5/9 return { "10_divided_by_3" : DIV(10)(3) , "12_divided_by_2" : DIV(12)(6) , "5_divided_by_9" : DIV(5)(9) } }4f:T495,{ // Convert the abstract Boolean function to a JavaScript Boolean value var do_div = div_next => count => remainder => divisor => // Should we continue with recursion? lib.to_boolean(lib.IS_LTE(divisor)(remainder)) // Yup, call div_next with an incremented counter, a new remainder // (of the divisor subtracted from the old remainder) and the divisor ? div_next(lib.SUCC(count)) (lib.SUBTRACT(remainder)(divisor)) (divisor) // Nope, we've reached the end so return an object containing the // the counter (now the quotient) and whatever is left over in the // remainder : { quotient : lib.to_integer(count) , remainder: lib.to_integer(remainder)} var DIV = val1 => val2 => Y(do_div)(lib.ZERO)(val1)(val2) // Now we need to combine the two quantity functions into a PAIR // before passing them to div return { "10_divided_by_3" : DIV(lib.TEN)(lib.THREE) , "12_divided_by_2" : DIV(lib.TWELVE)(lib.SIX) , "5_divided_by_9" : DIV(lib.FIVE)(lib.NINE) } }50:T574,{ var do_div = div_next => count => remainder => divisor => // Should we continue with recursion? lib.to_boolean(lib.IS_LTE(divisor)(remainder)) // Yup, call div_next with an incremented counter, a new remainder // (of the divisor subtracted from the old remainder) and the divisor ? div_next(lib.SUCC(count)) (lib.SUBTRACT(remainder)(divisor)) (divisor) // Nope, we've reached the end so return a PAIR formed from the // the counter (now the quotient) and whatever is left over in the // remainder : lib.PAIR(count)(remainder) var DIV = val1 => val2 => Y(do_div)(lib.ZERO)(val1)(val2) // Extract the quotiernt and dividend parts of the result pair before converting // them back to integers return { "10_divided_by_3_quotient": lib.to_integer(lib.HEAD(DIV(lib.TEN)(lib.THREE))) , "10_divided_by_3_dividend": lib.to_integer(lib.TAIL(DIV(lib.TEN)(lib.THREE))) , "12_divided_by_2_quotient": lib.to_integer(lib.HEAD(DIV(lib.TWELVE)(lib.SIX))) , "12_divided_by_2_dividend": lib.to_integer(lib.TAIL(DIV(lib.TWELVE)(lib.SIX))) , "5_divided_by_9_quotient": lib.to_integer(lib.HEAD(DIV(lib.FIVE)(lib.NINE))) , "5_divided_by_9_dividend": lib.to_integer(lib.TAIL(DIV(lib.FIVE)(lib.NINE))) } }51:T75c,md`Great, so we now have a function that can divide one quantity function by another and give back a PAIR function as the answer. We know this PAIR function contains two quantity functions - the first representing the quotient and the second the remainder - so we can extract them (using HEAD and TAIL) and then reify them to give actual integers. ## Should We Stop Here Or Carry On? Well, the point we've now reached is a good place to stop if you want. Inside function do_div, the only JavaScript operator still in use is the ternary operator, and this performs a very useful service - not only because it acts as a compact way to represent an If/Then/Else construct, but more importantly, JavaScript is smart enough to test the condition first, and then only process the branch that corresponds to the success or failure of the condition. If we want to take the next step and eliminate the use of the ternary operator, then we need to be careful. As soon as we remove the use of this operator, JavaScript will look at the IS_LTE function as exactly that - just a function and not a condition operator. Therefore, JavaScript will automatically attempt to evaluate both the true ***and*** false branches of the condition. Apart from this being a nonsensical thing to do (since a condition cannot be both true and false simultaneously), it will also lead to run-away recursion. ### Remove The Use Of The JavaScript Ternary Operator Ok, so lets take the plunge and remove the use of the JavaScript ternary operator. This means that the call to div_next must go in parentheses to delimit it as the condition's "true" branch, and similarly the call to PAIR must also go in parentheses since that is the condition's "false" branch. `52:T5c7,{ // Remove the use of the JavaScript ternary operator var do_div = div_next => count => remainder => divisor => // Should we continue with recursion? lib.IS_LTE(divisor)(remainder) // Yup, call div_next with an incremented counter, a new remainder // (of the divisor subtracted from the old remainder) and the divisor (div_next(lib.SUCC(count)) (lib.SUBTRACT(remainder)(divisor)) (divisor)) // Nope, we've reached the end so return a PAIR formed from the // the counter (now the quotient) and whatever is left over in the // remainder (lib.PAIR(count)(remainder)) var DIV = val1 => val2 => Y(do_div)(lib.ZERO)(lib.PAIR(val1)(val2)); // Extract the quotiernt and dividend parts of the result pair before converting // them back to integers return { "10_divided_by_3_quotient": lib.to_integer(lib.HEAD(DIV(lib.TEN)(lib.THREE))) , "10_divided_by_3_dividend": lib.to_integer(lib.TAIL(DIV(lib.TEN)(lib.THREE))) , "12_divided_by_2_quotient": lib.to_integer(lib.HEAD(DIV(lib.TWELVE)(lib.SIX))) , "12_divided_by_2_dividend": lib.to_integer(lib.TAIL(DIV(lib.TWELVE)(lib.SIX))) , "5_divided_by_9_quotient": lib.to_integer(lib.HEAD(DIV(lib.FIVE)(lib.NINE))) , "5_divided_by_9_dividend": lib.to_integer(lib.TAIL(DIV(lib.FIVE)(lib.NINE))) } }53:T5d9,{ // Remove the use of the JavaScript ternary operator var do_div = div_next => count => remainder => divisor => // Should we continue with recursion? lib.IS_LTE(divisor)(remainder) // Yup, call div_next with an incremented counter, a new remainder // (of the divisor subtracted from the old remainder) and the divisor (fn => (div_next(lib.SUCC(count)) (lib.SUBTRACT(remainder)(divisor)) (divisor)) (fn)) // Nope, we've reached the end so return a PAIR formed from the // the counter (now the quotient) and whatever is left over in the // remainder (lib.PAIR(count)(remainder)) var DIV = val1 => val2 => Y(do_div)(lib.ZERO)(val1)(val2) // Extract the quotient and dividend parts of the result pair before converting // them back to integers return { "10_divided_by_3_quotient": lib.to_integer(lib.HEAD(DIV(lib.TEN)(lib.THREE))) , "10_divided_by_3_dividend": lib.to_integer(lib.TAIL(DIV(lib.TEN)(lib.THREE))) , "12_divided_by_2_quotient": lib.to_integer(lib.HEAD(DIV(lib.TWELVE)(lib.SIX))) , "12_divided_by_2_dividend": lib.to_integer(lib.TAIL(DIV(lib.TWELVE)(lib.SIX))) , "5_divided_by_9_quotient": lib.to_integer(lib.HEAD(DIV(lib.FIVE)(lib.NINE))) , "5_divided_by_9_dividend": lib.to_integer(lib.TAIL(DIV(lib.FIVE)(lib.NINE))) } }54:T4da,{ // Remove the use of the JavaScript ternary operator var do_div = div_next => count => remainder => divisor => // Should we continue with recursion? lib.IS_LTE(divisor)(remainder) // Yup, call div_next with an incremented counter, a new remainder // (of the divisor subtracted from the old remainder) and the divisor (fn => (div_next(lib.SUCC(count)) (lib.SUBTRACT(remainder)(divisor)) (divisor)) (fn)) // Nope, we've reached the end so return a PAIR formed from the // the counter (now the quotient) and whatever is left over in the // remainder (lib.PAIR(count)(remainder)) var DIV = val1 => val2 => Y(do_div)(lib.ZERO)(val1)(val2) var MOD = val1 => val2 => lib.TAIL(Y(do_div)(lib.ZERO)(val1)(val2)) // Reify the quantity function values returned by MOD for (10 mod 3), (12 mod 6) and (5 mod 9) return { "10_mod_3" : lib.to_integer(MOD(lib.TEN)(lib.THREE)) , "12_mod_2" : lib.to_integer(MOD(lib.TWELVE)(lib.SIX)) , "5_mod_9" : lib.to_integer(MOD(lib.FIVE)(lib.NINE)) } }55:T1632,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); 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)); 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, 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 } }56:[] 48:{"id":"0bd41af881555117","slug":"mindshift-part-12","title":"Mindshift: Part 12","thumbnail":"e889f2f1efd85c2e2b3f48a1064256f0d23b029e290376b5f498c0c6fa5384c6","access_level":"public","create_time":"$D2018-02-13T23:11:36.807Z","update_time":"$D2020-01-10T18:27:57.355Z","view_time":null,"first_public_time":"$D2018-02-14T00:29:48.494Z","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":219,"publish_version":219,"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 12","cells":[{"id":0,"value":"md`# Mindshift: Part 12\n\nRepublished on Dec 12th, 2018\n\n# Divide And Conquer\nNow that we have the ability to perform recursive functions, we can define a division function.\n\nThe process of dividing value1 by value2 is simply keeping track of how times value2 can be subtracted from value1 until value2 becomes larger than the remainder. The answer is then two values: the count of how many times we performed the subtraction, and whatever number is over left.\n\nTo keep things simple, we will just return an integer remainder rather than a decimal fraction.\n\nSo let's write out the division operation as a regular JavaScript arrow function that uses recursion. Then we will convert it to use the Y-Combinator and abstract quantity functions.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":8,"value":"{\n // Define division using recursive subtraction\n var div =\n count =>\n remainder =>\n divisor =>\n // Should we continue with recursion?\n (divisor <= remainder)\n // Yup, call div_next with an incremented counter, a new remainder\n // (of the divisor subtracted from the old remainder) and the divisor\n ? div(count + 1)(remainder - divisor)(divisor)\n\n // Nope, we've reached the end so return an object containing the\n // the counter (now the quotient) and whatever is left over in the\n // remainder\n : { quotient : count\n , remainder: remainder}\n\n // Return the answers to 10/3, 12/6 and 5/9\n return {\n \"10_divided_by_3\" : div(0)(10)(3)\n , \"12_divided_by_2\" : div(0)(12)(6)\n , \"5_divided_by_9\" : div(0)(5)(9)\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":11,"value":"md`Well ok, that works; but the API to the div function is not exactly intuitive. We want to divide one number by another, yet this function requires three parameters instead of the expected two. It's a pretty poor API design to expect the user to know they should also supply some internal implementation value such as the initial value of the quotient counter.\n\nThe above implementation is exactly ***not*** how people expect a division function to work - so we'll have to fix that.\n\nAll we need to do is to treat the existing div function as an inner function (let's rename it do_div), and then create a new div function that acts as the public API to do_div and passes in the initial value of the quotient counter.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":13,"value":"{\n // Define division using recursive subtraction\n var do_div =\n count =>\n remainder =>\n divisor =>\n // Should we continue with recursion?\n (divisor <= remainder)\n // Yup, call div_next with an incremented counter, a new remainder\n // (of the divisor subtracted from the old remainder) and the divisor\n ? do_div(count + 1)(remainder - divisor)(divisor)\n\n // Nope, we've reached the end so return an object containing the\n // the counter (now the quotient) and whatever is left over in the\n // remainder\n : { quotient : count\n , remainder: remainder}\n\n // Create a \"div\" partial function in order to hide the need\n // for the user to supply the initial quotient value\n var div = do_div(0);\n \n // Return the answers to 10/3, 12/6 and 5/9\n return {\n \"10_divided_by_3\" : div(10)(3)\n , \"12_divided_by_2\" : div(12)(6)\n , \"5_divided_by_9\" : div(5)(9)\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":21,"value":"md`Ok, that's a lot more user friendly.\n\n### Now Use The Y-Combinator For Recursion\nNext, we can remove do_div's self-reference by using the Y-Combinator. However, as we've seen before, the Y-Combinator requires that the function being called recursively has as its first parameter, the function to be called next. So we'll give do_div a new first parameter called div_next and where we used to call do_div using its external name, we will replace this with a call to the function received in parameter div_next.\n\nThen we need to modify the definition of div to call the Y-Combinator using do_div.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":26,"value":"// The Universal combinator\nU = fn => fn(fn)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":29,"value":"// The Y-Combinator\nY = (rec_fn =>\n (gen_rec => U(gen_rec))\n (gen_rec => rec_fn((n,a,b) => U(gen_rec)(n,a,b)))\n )","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":23,"value":"$4c","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":33,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":39,"value":"$4e","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":45,"value":"md`Good. So far we haven't broken anything.\n\nSo, how about changing remainder and divisor from integers to quantity functions?\n\nSo to do this, we must look at what operations are we performing on these two parameters. First we're comparing them using the \"less than or equal\" operator, then we're subtracting divisor from remainder.\n\nFortunately for us, we already know how to perform these operations on abstract quantity functions. We already have an IS_LTE function and a SUBTRACT function (see the lib object at the end of this blog for the definitions of these functions)`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":47,"value":"{\n // Treat remainder and divisor as abstract quantity functions instead of JavaScript integers\n var do_div =\n div_next =>\n count =>\n remainder =>\n divisor =>\n // Should we continue with recursion?\n lib.to_boolean(lib.IS_LTE(divisor)(remainder))\n // Yup, call div_next with an incremented counter, a new remainder\n // (of the divisor subtracted from the old remainder) and the divisor\n ? div_next(lib.SUCC(count))\n (lib.SUBTRACT(remainder)(divisor))\n (divisor)\n // Nope, we've reached the end so return an object containing the\n // the counter (now the quotient) and whatever is left over in the\n // remainder\n : { quotient : lib.to_integer(count)\n , remainder: lib.to_integer(remainder)}\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":51,"value":"md`Oh, hang on a minute - that's not going to work is it?\n\nThe problem here is that the IS_LTE function is not a JavaScript predicate function. That is, it returns one of the abstract Boolean functions TRUE or FALSE rather than a JavaScript Boolean value; therefore, it will not work correctly with the JavaScript ternary operator.\n\nFor the time being though, we'll take the easy option and convert the result from IS_LTE into a JavaScript Boolean value: that way, we're not changing too much coding all at once.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":73,"value":"$4f","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":78,"value":"md`Now, use a PAIR function as the return value instead of a JavaScript object.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":81,"value":"$50","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":84,"value":"$51","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":86,"value":"$52","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":89,"value":"md `KABOOM!\n\nWell, we were expecting that to happen...\n\nTo avoid runaway recursion, we need to refactor the call to div_next by wrapping it in another function.\n\nHow many parameters should this wrapper function take? Well, that depends on how many parameters the function being wrapped takes.\n\nGenerally speaking, the job of the <some_name>_next function (div_next in our case) is to perform the next step of the recursive calculation, and this will take whatever value is first passed to the Y-Combinator. In our case, this is a single PAIR function; therefore, this wrapper function needs to take one parameter.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":94,"value":"$53","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":96,"value":"md`So there you have it...\n\nA function that implements the division operator by means of the Y-Combinator recursively calling a function that uses repeated subtraction and calculate the quotient and remainder. This results is then returned as a PAIR function.\n\n\n\n\n\n\n## Now, It's But A Small Step To Create A Modulus Function\n\nIf we want to create a MODulus function, then we've actually done all the leg work already. Since the modulus function is a division operation that ignores the quotient and returns the remainder, we can define the MOD function to be simply the PAIR of the PAIR returned from DIV.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":99,"value":"$54","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":103,"value":"md`So we have now expanded our set of arithmetic tools to include division and modulus.\n\nIn the next blog, we'll take a look at how lists can be implemented. Then once we have a list, we can implement the functions MAP, REDUCE and RANGE on the list.\n\n\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":37,"value":"$55","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W56","stdlib":"1"}} 24:null