return (n===0) ? 1 : n * make_factorial(make_factorial)(n-1);
const op = (x,y) => x*y; //similar to op in accumulate(op, init, xs)
return t => op(n,t); //op constructor
n => n === 0
? 1 //base case
: gen(n) //do something at this layer
(func(func)(n - 1))) //wishful thinking
//previous two lines are like op(n, accumulate(the_rest))
In the program above,
gen(n) is used to generate an operator function using function
In the 2015 CS1101S mid-term quiz, it asks whether the following functions exhaust time and/or space resources.
const C = (x => x(x))(x => x(x));
const D = (x => (x(x))(x))(x => x(x));
const E = (x => x(x(x)))(x => x(x));
const F = (x => x(x))(x => x(x(x)));
I had no idea how this works until I read something on *Lambda Calculus*, so I’ll briefly introduce how it works:
Consider the one of the simplist lambda expression: `λx. x+1`. It means in a blackbox function, it receives one parameter named `x` and outputs the result `x+1`. The `λ` sign…
TL;DR: always merge to
master is stablized and deployed, merge to
stable tagged with a release number.
The main branch should be considered
origin/master and will be the main branch where the source code of HEAD always reflects a state with the latest delivered development changes for the next release. As a developer, you will be branching and merging from master.
origin/stable to always represent the latest code deployed to production. During day to day development, the stable branch will not be interacted with.
When the source code in the master branch is stable and has been…