Category: Lambda

This is a good article because it takes a deeper dive into stuff that Redux articles tend to skim over.

This is a good article because it takes a deeper dive into stuff that Redux articles tend to skim over. Of course the real action of your Redux app occurs in the middleware, not the reducers.

It’s good that after a survey of middleware techniques he settled on abstracting RxJS in his own domain specific library. The other approaches which are more common in the Redux world are frankly quite inadequate. Sagas for example (which are built on JavaScript generators) are way too complex once you get beyond trivial examples.

https://medium.com/@jeffbski/where-do-i-put-my-business-logic-in-a-react-redux-application-9253ef91ce1

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