Category: Lambda

I don’t know Purescript* but I may need to start looking into it to understand these articles.

I don’t know Purescript* but I may need to start looking into it to understand these articles.

Here is the follow up on incrementally updating the DOM using functions. http://blog.functorial.com/posts/2018-04-08-Incrementally-Improving-The-DOM.html

* my impression of it so far is that it’s a simplified Haskell designed for easy JavaScript interoperability.

http://blog.functorial.com/posts/2018-03-12-You-Might-Not-Need-The-Virtual-DOM.html

Lambda calculus expansions are cool.

Lambda calculus expansions are cool.

The reduceRight() array operator can be defined by pattern matching one of these two cases:

[ ].reduceRight(f, acc) → acc

[x, … xs].reduceRight(f, acc) → f(xs.reduceRight(f, acc), x)

i.e. An empty array right reduces simply to the value of its accumulator.

A non-empty array right reduces to its function being applied to a right reduction of its tail with its head being used as the accumulator.

Redux requires a new state to be created on every update of the store.

Redux requires a new state to be created on every update of the store. The usual, cheapest way to do this is by shallow copying the state to create a new state.

Andrea Giammarchi developed a different way in which the new store is prototypically inherited from the previous state. This library is significantly faster than shallow copying, especially when the number of keys in the store grows large. It also has features for managing depth and compressing the state from time to time.

https://github.com/WebReflection/protostate

Yet another discussion of monads for JavaScript dimwits.

Yet another discussion of monads for JavaScript dimwits.

It’s interesting to me that idea of “programmable semicolons” makes complete sense to functional programmers (for whom a program is really just one big expression) and basically none to imperative programmers who think in terms of program statements which evolve their computation through variables.

Chainable or composable units of computation are really what this is all about.

http://sean.voisen.org/blog/2013/10/intro-monads-maybe/