Denis Stoyanov xgrommx

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

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.

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)

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".

Disclaimer 1: Первую которая "про то чего мы достигли" я таки пропустил.

Disclaimer 2: Многие доклады смотрелись и отчёты писались в состоянии алкогольного опьянения.

1. Ben Alpert - What Lies Ahead

Сейчас посмотрел Ben Alpert - What Lies Ahead она про то какие идеи они имеют о дальнейшем развитии. И они делят на UX-идеи и DX-идеи. В UX у них:

	module Main where

	import Prelude

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

	import Data.Profunctor

	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())

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

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

	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 = () => {}

	{-# language KindSignatures #-}
	{-# language PolyKinds #-}
	{-# language DataKinds #-}
	{-# language TypeFamilies #-}
	{-# language RankNTypes #-}
	{-# language NoImplicitPrelude #-}
	{-# language FlexibleContexts #-}
	{-# language MultiParamTypeClasses #-}
	{-# language GADTs #-}
	{-# language ConstraintKinds #-}