Denis Stoyanov xgrommx

I recently read this interesting post about eventual values. One thing that struck me and which I failed to understand is:

Eventual Values can be interacted with like normal values.

If an Eventual Value is part of a simple value operation, then that expression resolves to a new Eventual > Value which resolves when all its Eventual Values are resolved.

If I understood the author correctly, that is supposed to be solving several problems:

"I don’t know if this is a Promise or not" (I don't know if it's the resolved result of the action, or the action itself).
"I’d really like to write code that interacts with values, and not Promises, and leave the machinery to the computer to work out".

Setoid

S.equals(a, a) = true (reflexivity)
S.equals(a, b) = S.equals(b, a) (symmetry)
If S.equals(a, b) and S.equals(b, c), then S.equals(a, c) (transitivity)

Semigroup

S.concat(S.concat(a, b), c) is equivalent to S.concat(a, S.concat(b, c)) (associativity)

Transducers are composable algorithmic transformations. They are independent from the context of their input and output sources and specify only the essence of the transformation in terms of an individual element. Because transducers are decoupled from input or output sources, they can be used in many different processes - collections, streams, channels, observables, etc. Transducers compose directly, without awareness of input or creation of intermediate aggregates.

Original source code (from Oct 12, 2014):

Transducers.kt: https://gist.github.com/Spasi/4052e4e8c8d88a7325fb
TransducersTest.kt: https://gist.github.com/Spasi/2a9d7d420b20f37513d5

Change notes:

Converted to Kotlin 1.0.0-beta-3595 and JUnit 4.12.

Node streams - a fractal of weird design

and a potential refactor that could fix that

This is a list of issues and confusions I've encountered with node streams, and things I wish were designed and implemented differently. If promise-streams is ever going to change to a design that doesn't build on top of node streams, this would be a list of mistakes to avoid

enc parameter - Why is encoding always passed together with the data? It should be a separate concern. It doesn't even make sense in objectMode
eventemitter base - This encourages a lot of random events to be "attached" by other authors which doesn't work. Best to have an uniform (typed) interface so that everyone knows what to expect.
relying on nextTick etc for execution order - This is very unreliable and causes all sorts of unpredictable rules for implementers which are not documented anywhere. When you attach listeners determines what will happen.
no error propagation - we need the

A lot of people mentioned other immutable JS libraries after reading my post. I thought it would be good to make a list of available ones.

There are two types of immutable libraries: simple helpers for copying JavaScript objects, and actual persistent data structure implementations. My post generally analyzed the tradeoffs between both kinds of libraries and everything applies to the below libraries in either category.

Libraries are sorted by github popularity.

	function loadSomeStuff(id) {
	// We return basic-stream https://github.com/rpominov/basic-streams
	return _sink => {
	let sink = _sink
	const onSuccess = data => sink({type: 'success', data})
	const onError = error => sink({type: 'error', error})
	stuffLoadingService.load(id).done(onSuccess, onError)
	return () => {
	// We can't unsubscribe from a Promise, so we simply make sink() a noop
	sink = () => {}

	import { combineReducers } from 'redux';
	import users from './reducers/users';
	import posts from './reducers/posts';

	export default function createReducer(asyncReducers) {
	return combineReducers({
	users,
	posts,
	...asyncReducers
	});

	module Test.Main where

	import Prelude (Applicative, Apply, Functor, Show, Unit(), (<*>), (<>), (<$>), ($), (<<<), id, bind, map, pure, return, unit)

	import Control.Applicative.Free (FreeAp(), NaturalTransformation(), liftFreeAp, foldFreeAp)
	import Control.Apply (lift2)
	import Control.Monad.Eff (Eff())

	import DOM (DOM())
	import DOM.Node.Types (Element())

	module Main where

	import Prelude

	import Data.Maybe
	import Data.Either
	import Data.Tuple
	import Data.List

	import Data.Profunctor

	quicksort :: (Ord a) => [a] -> [a]
	quicksort [] = []
	quicksort (x:xs) =
	let smallerSorted = quicksort (filter (<=x) xs)
	biggerSorted = quicksort (filter (>x) xs)
	in smallerSorted ++ [x] ++ biggerSorted