44:["$","title",null,{"children":"Mindshift: Part 9 | Chris Whealy | Observable"}] 4c:T764,md`# Mindshift: Part 9 Republished on Feb 5th, 2018 # Preparing For Combinators Before we can define the Y-Combinator, we first need to look at how recursion can be performed using only anonymous functions. And before we can define recursion using anonymous functions, we must first understand some principles that will help us design and then refactor our code. These principles don't focus on what a function does; instead, they show us how functions can be manipulated, combined and restructured without altering their functionality. These concepts are: 1. Higher Order Functions 2. Fixed Points 3. Functional Refactoring 3.1 Tennent's Correspondence Principle 3.2 Function Wrapping 3.3 Inline Definition ## 1) Higher Order Functions A higher order function is simply a function that either takes another function as a parameter, or gives back a function as a return value, or both. In the [Mindshift Part 4](https://beta.observablehq.com/@chriswhealy/mindshift-part-4) and [Mindshift Part 5](https://beta.observablehq.com/@chriswhealy/mindshift-blog-part-5) blogs, we saw some examples of partial functions - the adder and multiplier functions to be specific. In each case, when you pass only one parameter to the adder or multiplier functions, they give you back another function that firstly contains an incomplete definition of how to perform the operation, and secondly takes one parameter that supplies the missing value needed to complete the operation. Both adder and multiplier are examples of higher order functions. Another important example of a higher order function is the concept of function composition. An example will probably help here. `4d:T58e,md`## 2) Fixed Points The simplest way to demonstrate the fixed point of a function is for you to have a rummage around in that box in the [cupboard under the stairs|attic|basement] or wherever you have all your college/university stuff, and dig out your scientific calculator. In my case, this is a [Casio fx-180P](http://www.rskey.org/CMS/index.php/exhibit-hall/7?manufacturer=Casio&model=fx-180P) (yes, I know, such devices can now only be found either in museums of computing or on my desk...) Set the calculator to work in radians instead of degrees, then type in any number - say 3 - and then press the cos button. Now press cos again, and again, and again and again and again and again and again and again and again and again... You get the idea. As you keep pressing the cos button, you'll notice that the result starts to converge to an unchanging value. On the limited precision of my 1980's calculator, this convergence happens after about 60 recursions of cos. What's happened is that the cosine function has reached a point where the value going in is the same as the value coming out. In other words, the cosine function has reached its *"fixed point"*; which in the case of the cosine function is 0.7390851332151607 radians. In other words cos(0.7390851332151607) = 0.7390851332151607. `4e:Tac9,md`Other well-known functions also have fixed points: for instance the sine function has one fixed point sin(0) = 0, and the square root function has two fixed points sqrt(0) = 0 and sqrt(1) = 1. There are also some functions that have no fixed points: for instance the values coming out of the function x => x + 1 will never converge because whatever value of x is supplied can never equal itself plus one. ## Using a "Functional" to Find the Fixed Point The simple example above illustrates the concept that the cosine function has a static value, and that such static values are known as "*fixed points*". However, rather than having to write a specific process for each function whose fixed point we want to locate, wouldn't it be better to find some general purpose function that takes another function as input, and gives you back the fixed point of that function. So for instance:

// Y is the mystery function that turns 'Math.cos' into 0.7390851332151607
var a = Y(Math.cos);  // -> a = 0.7390851332151607
Math.cos(a) === a;    // -> true

Y(Math.cos) === Math.cos(Y(Math.cos)); // -> true

Any function that takes another function as input is known as a **functional**. This does not change the concept of a fixed point at all, but it does restate the question. To continue with the cosine example, instead of describing the fixed point of the cos function in terms that ask: *"What value should I pass to cos in order to get the same value back?"* We are now asking: *"What functional Y is there that when passed the cos function, will give us back the fixed point of cos?* But we're jumping ahead of ourselves here. ## 3) Functional Refactoring ### 3.1) Tennent's Correspondence Principle In his 1981 book, [Principles of Programming Languages](http://www.amazon.com/Principles-Programming-Languages-International-Computing/dp/0137098731), the author, R.D. Tennent, lays out a very simple correspondence; namely that if an expression is wrapped in a function that takes no arguments and is then immediately invoked, this will have no effect on the value of the expression. This is a true refactoring because we have altered the structure of the code without altering its functionality. Here we can first refactor the multiplier and adder functions, then we can refactor the double and add5 functions (derived from multiplier and adder), and finally, we can refactor the compose function. `4f:T74d,md`Each time we apply a refactoring, we rearrange the code in such a way that its structure is altered without changing any functionality. But before you run screaming from the room at the addition of all these supposedly futile layers of indirection, consider the effect function wrapping has on the function being wrapped. Since we are wrapping a function within another function, that inner function will not be evaluated until the wrapper function is invoked. Therefore, we have implemented a delay tactic. The evaluation of the inner function is now delayed until the wrapper function is called. For languages such as Haskell and Scala that employ lazy evaluation, this type of refactoring is superfluous, but in strict evaluation languages such as JavaScript or Ruby, this is a very important tool. It prevents the evaluation of functions that would otherwise cause the language interpreter to disappear down the rabbit hole of infinite recursion. ### 3.3) Inline Function Definition Finally, let's look at the inline definition of functions. The point of this type of refactoring is more to demonstrate one of the underlying principles of [Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus), rather than to demonstrate any programming technique useful to humans. Nonetheless, it does produce some amusing (and certainly cryptic) results.¹ The principle of inline function definition means that wherever a function name is seen, you can replace that name with the function definition itself. In other words, we treat the function name as if it were a macro, and then substitute the macro's code every time we see the macro name. Let's remove all the previous types of refactoring, and simply apply the concept of inline function definition. `50:T14e9,md`Whilst the ongoing process of inline function substitution makes the coding less and less human-readable (and therefore, less useful to us), it illustrates the point that from nothing more than simple functions that take one parameter and contain only a single expression, we can build up much more complex calculations. ### Summary of Inline Function Definition Apart from generating seemingly unintelligible code, the remarkable thing about inline function definition is that the final result has been constructed from nothing more than the combination of three _**very**_ simple concepts: | Concept | Example | |---|---| | Expression evaluation | x + 1 | | Function definition | x => x + 1 | | Function application | (x => x + 1)(2) |
The fact that we might give a function such as x => x + 1 the name incr is merely a convenience for us humans. If you've ever used a language that supports macros, the inline function substitution is exactly what happens when, at compile time, a macro name is replaced by the code it represents. ## So Where Does This Leave Us? Now that we have some practical experience with this low-level style of functional programming, whether you realise it or not, you now have some working experience with [Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus), and specifically, this final result is an example of a Lambda expression. Within the basic definition of Lambda Calculus, the only data type is the function. Furthermore, there are no variable assignments anywhere. The only binding of values to names happens when parameters are passed to a function. We know from the derivations shown in this blog that although the above coding appears to be completely cryptic, it is actually composed from little functions that, taken individually, are in fact very simple. However, if you were to show this code to someone who did not have the background understanding contained in this blog, they might understandably state that the code is not easy to understand. (See my earlier blog on avoiding the popular confusion that can be created by thinking that "simple" and "easy" are synonyms) I'm not suggesting we should start writing code like this - far from it - but the important thing to understand is that by combining (named or anonymous) functions in the way we have done, we have achieved the goal described by Tony Hoare of creating a software design so simple, that it obviously contains no errors - as opposed to creating a software design so complex that it contains no obvious errors. (See the Mindshift: Part 4 blog for details) It is clear that in a real-world programming scenario, no one would develop a unit of code to "double a number then add 5" in the form of (fn1=>fn2=>val=>fn2(fn1(val)))((p=>q=>q*p)(2))((p=>q=>q+p)(5)); that would be ridiculous. Instead, you would follow the original approach of building up function calls using placeholder names such as multiplier or add5 or compose. But the final step of using inline function definitions is exactly what happens at runtime whenever macro expansion takes place. So, after a considerable amount of preparatory leg-work, we now have the necessary tools to take a normal recursive function and refactor it to use only anonymous functions. This will be the topic of my next blog. Chris W

Next Blog

### Footnotes 1) As some of you may have noticed, up till now, I have stoically avoided any mention of mathematical concepts such as the Lambda Calculus. This is because 20 years of software training experience has taught me that students can learn a new concept far more effectively through practical, hands-on experience, than they can by seeing it only in a sterile and abstract form. I dislike the style of teaching that starts with something abstract, and from it, tries to derive something concrete. To me, this teaching style does a great disservice to the majority of students because only about 20% of the population can grasp a new principle as a purely abstract concept. The remaining 80% need to handle it, work with it, and see it in action before the learning process becomes effective. This is why I always start with concrete examples and then from them, derive whatever abstract representations may be useful. However, we will soon get to the point where we can look directly at the Lambda Calculus; and I trust that by the time we do, these preparatory blogs will have given you a good working understanding of how abstract functions can be used to define anything that is "effectively computable". In other words I'm teaching you the Lambda Calculus by seeing it implemented in practice, rather than as a sterile (and therefore meaningless) abstraction.`51:T1314,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); // ******************************************************************** // Reification functions // ******************************************************************** var to_integer = qtyFn => qtyFn(incr)(0); var to_string = qtyFn => qtyFn(asPlusChar)(''); var to_boolean = fn => fn(true)(false); // ******************************************************************** // Functions that operate on pairs // ******************************************************************** var PAIR = val1 => val2 => fn => fn(val1)(val2); var TRUE = true_part => false_part => true_part; var FALSE = true_part => false_part => false_part; var HEAD = pair => pair(TRUE); var TAIL = pair => pair(FALSE); // ******************************************************************** // Define an abstract quantity function for ZERO. // ******************************************************************** var ZERO = transform => start_value => start_value; // ******************************************************************** // Successor and predecessor functions // ******************************************************************** var SUCC = qtyFn => transform => start_value => transform(qtyFn(transform)(start_value)); var SUCC_PAIR = pair => PAIR(pair(FALSE))(SUCC(pair(FALSE))); var PRED = qtyFn => qtyFn(SUCC_PAIR)(PAIR(ZERO)(ZERO))(TRUE); // ******************************************************************** // Now each quantity function can be defined simply as the successor // of the quantity function before it. // ******************************************************************** var ONE = SUCC(ZERO); var TWO = SUCC(ONE); var THREE = SUCC(TWO); var FOUR = SUCC(THREE); var FIVE = SUCC(FOUR); var SIX = SUCC(FIVE); var SEVEN = SUCC(SIX); var EIGHT = SUCC(SEVEN); var NINE = SUCC(EIGHT); var TEN = SUCC(NINE); // ******************************************************************** // Arithmetic operations based on abstract quantity functions // ******************************************************************** var ADD = qtyFn1 => qtyFn2 => qtyFn1(SUCC)(qtyFn2); var MULTIPLY = qtyFn1 => qtyFn2 => qtyFn1(ADD(qtyFn2))(ZERO); var POWER = qtyFn1 => qtyFn2 => qtyFn2(MULTIPLY(qtyFn1))(ONE); var SUBTRACT = qtyFn1 => qtyFn2 => qtyFn2(PRED)(qtyFn1); // ******************************************************************** // 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, ZERO : ZERO, SUCC : SUCC, SUCC_PAIR : SUCC_PAIR, PRED : PRED, ONE : SUCC(ZERO), TWO : SUCC(ONE), THREE : SUCC(TWO), FOUR : SUCC(THREE), FIVE : SUCC(FOUR), SIX : SUCC(FIVE), SEVEN : SUCC(SIX), EIGHT : SUCC(SEVEN), NINE : SUCC(EIGHT), TEN : SUCC(NINE), ADD : ADD, MULTIPLY : MULTIPLY, POWER : POWER, SUBTRACT : SUBTRACT, NOT : NOT, AND : AND, OR : OR, XOR : XOR, IS_ZERO : IS_ZERO, IS_LTE : IS_LTE, IS_LT : IS_LT } }52:[] 48:{"id":"65f5bba49fb599ea","slug":"mindshift-part-9","title":"Mindshift: Part 9","thumbnail":"7929f6d2d7825f7d5666cd2e6e01509c0ebe3802c0b0e4e102739133cf264de1","access_level":"public","create_time":"$D2018-02-03T17:08:43.520Z","update_time":"$D2020-01-10T18:25:53.892Z","view_time":null,"first_public_time":"$D2018-02-05T02:29:14.379Z","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":212,"publish_version":212,"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":1,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Mindshift: Part 9","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":16,"value":"// Use the higher order multiplier and adder functions to create partial functions that respectively\n// double and add 5 to their subsequent operands\ndouble = lib.multiplier(2)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":20,"value":"add5 = lib.adder(5)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":24,"value":"// Double a number, then add 5 to it\nadd5(double(3))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":28,"value":"// Create a higher order function that can combine, or \"compose\", the functionality of two other functions\ncompose = fn1 => fn2 => val => fn2(fn1(val))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":27,"value":"// Now we can take the double and add5 function and \"compose\" them into a single function\ndoubleAndAdd5 = compose(double)(add5)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":34,"value":"doubleAndAdd5(3)","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":36,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":40,"value":"fp_cos = {\n // Find the fixed point of the Cosine function (in radians)\n var x = 3;\n \n while (x !== Math.cos(x)) {\n x = Math.cos(x)\n }\n \n return x;\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":62,"value":"$4e","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":104,"value":"{\n // Apply Tennent's Correspondence Principle (TCP) to the multiplier &\n // adder functions.\n // var multiplier = p => q => q*p;\n // var adder = p => q => q+p;\n // becomes:\n var multiplier = p => q => (() => q*p)();\n var adder = p => q => (() => q+p)();\n\n // Now apply TCP to the double and add5 functions\n // var double = multiplier(2);\n // var add5 = adder(5);\n // becomes:\n var double = (() => multiplier(2))();\n var add5 = (() => adder(5))();\n\n // Finally, apply TCP to the compose function\n // var compose = fn1 => fn2 => val => fn2(fn1(val));\n // becomes:\n var compose = fn1 => fn2 => (() => val => fn2(fn1(val)))();\n\n // Compose function doubleAndAdd5 as before\n var doubleAndAdd5 = compose(double)(add5);\n\n // TCP refactoring has no effect on the final result\n return doubleAndAdd5(3);\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":106,"value":"md`You might now be asking \"*What's the point of refactoring a function using Tennent's Correspondence Principle if it has no effect?*\"\n\nWell, this technique is not intended to alter functionality, but instead, is used to delay the evaulation of that function. In any language that uses strict evaluation (such as JavaScript), this technique is vital to prevent a function from disappearing down the rabbit hole of infinite recursion. But in order to understand this, we must ask ourselves a further question:\n\n\"*What would happen if we passed one of these self-executing functions a parameter?*\"\n\nWell, we would have to do two things:\n\n 1. Invent a name for the parameter (say z)\n 2. Supply a parameter value when the function is invoked\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":161,"value":"{\n // Each of the self-executing functions inside multiplier and adder\n // now take a parameter \"z\". Since \"z\" is not used anywhere inside\n // either expression, we are free to assign this parameter any\n // value we like: hence the 123 and \"abc\".\n // In this case, these values have absolutely no effect on the\n // evaluation of the expression.\n var multiplier = p => q => (z => q*p)(123);\n var adder = p => q => (z => q+p)(\"abc\");\n\n // Create the double and add5 partial functions as before\n var double = (() => multiplier(2))();\n var add5 = (() => adder(5))();\n\n // Create a \"compose\" higher order function\n var compose = fn1 => fn2 => (() => val => fn2(fn1(val)))();\n\n // Compose function doubleAndAdd5 as before\n var doubleAndAdd5 = compose(double)(add5);\n\n // Supplying values to unused parameters has no effect on the final\n // result\n return doubleAndAdd5(3); // -> 11, just the same as before\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":163,"value":"md`\"*More futility!*\" I hear you cry.\n\nWell, I would ask you please to bear with me for a moment...\n\n### 3.2) Function Wrapping\nIn much the same way that Tennent's Correspondence Principle is able to leave the value of an expression unchanged by wrapping it inside a self-executing function, we can perform a similar refactoring by wrapping a function inside another function that we then immediately execute.\n\nFor simplicity, we'll put all the functions back to their original definition, then we'll apply function wrapping.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":169,"value":"{\n // The multiplier and adder functions without TCP refactoring\n // var multiplier = p => q => q*p;\n // var adder = p => q => q+p;\n\n // Refactor each function by wrapping it in a self-executing function that takes an unused parameter z\n var multiplier = p => z => (q => q*p)(z);\n var adder = p => z => (q => q+p)(z);\n\n // Create the double and add5 partial functions as before\n var double = multiplier(2);\n var add5 = adder(5);\n\n // Create a \"compose\" higher order function\n var compose = fn1 => fn2 => val => fn2(fn1(val));\n\n // Compose function doubleAndAdd5 as before\n var doubleAndAdd5 = compose(double)(add5);\n\n // Function wrapping has no effect on the final result\n return doubleAndAdd5(3);\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":173,"value":"$4f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":175,"value":"{\n // Treat the \"multiplier\" and \"adder\" functions as if they are macros\n // var multiplier = p => q => q*p;\n // var adder = p => q => q+p;\n // So instead of writing\n // var double = multiplier(2);\n // var add5 = adder(5);\n // we write\n var double = (p => q => q*p)(2);\n var add5 = (p => q => q+p)(5);\n \n return add5(double(3));\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":178,"value":"md`Similarly, wherever the functions double and add5 are used, we replace their names with their definitions.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":180,"value":"{\n // Functions \"double\" and \"add5\" are no longer needed explicitly\n // because we replace all occurrences of their names with their\n // definition\n // var double = (p => q => q*p)(2);\n // var add5 = (p => q => q+p)(5);\n\n // Create a \"compose\" higher order function\n var compose = fn1 => fn2 => val => fn2(fn1(val));\n\n // Replace occurrences of double and add5\n var doubleAndAdd5 = compose((p => q => q*p)(2))((p => q => q+p)(5));\n\n return doubleAndAdd5(3);\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":182,"value":"md`Continue the substitution process on the compose function...`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":184,"value":"{\n // Now \"compose\" is no longer needed as a named function\n // var compose = fn1 => fn2 => val => fn2(fn1(val));\n\n // Replace occurrences of compose (with some CRLFs for clarity)\n var doubleAndAdd5 = (fn1 => fn2 => val => fn2(fn1(val)))\n ((p => q => q*p)(2))\n ((p => q => q+p)(5));\n\n return doubleAndAdd5(3);\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":186,"value":"md`Heck, we've come this far, why not get rid of doubleAndAdd5?\n\nYeah, let's do it!`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":190,"value":"// Replace doubleAndAdd5 with its own definition and take out\n// the helpful spaces and carriage returns\n\n// This yields possibly the most cryptic piece of JavaScript you've\n// ever seen; but that's not the point. The point is that:\n// a) it works and,\n// b) we can be very confident of its correctness because we have\n// derived this expression from first principles!\n\n(fn1=>fn2=>val=>fn2(fn1(val)))((p=>q=>q*p)(2))((p=>q=>q+p)(5))(3)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":192,"value":"$50","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":79,"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