David Chase davidchase

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

Learning FP the hard way: Experiences on the Elm language

by Ossi Hanhinen, @ohanhi

with the support of Futurice 💚.

Licensed under CC BY 4.0.

Editorial note

Folder Structure

Please note

While this gist has been shared and followed for years, I regret not giving more background. It was originally a gist for the engineering org I was in, not a "general suggestion" for any React app.

Typically I avoid folders altogether. Heck, I even avoid new files. If I can build an app with one 2000 line file I will. New files and folders are a pain.

	// http://www.haskellforall.com/2013/02/you-could-have-invented-comonads.html

	const daggy = require('daggy');
	const {toUpper, prop, identity, range, curry, compose} = require('ramda');

	const Config = daggy.tagged("opts")

	Config.prototype.inspect = function() {
	return `Config(${this.opts})`
	}

	const daggy = require('daggy')
	const {compose, curry, map, prop, identity, intersection, union} = require('ramda');
	const inspect = (x) => { if(!x) return x; return x.inspect ? x.inspect() : x; }

	// F-algebras


	// Fix
	// ============
	// Fx is a simple wrapper that does almost nothing. It's much more useful in typed languages to check that we have a recursive f (Fix f)

	function mapValues(obj, fn) {
	return Object.keys(obj).reduce((result, key) => {
	result[key] = fn(obj[key], key);
	return result;
	}, {});
	}

	function pick(obj, fn) {
	return Object.keys(obj).reduce((result, key) => {
	if (fn(obj[key])) {

	#!/usr/bin/env bash

	# Browse Ramda documentation in Terminal
	# Requires jq and a tool such as fzf or peco for interactive filtering

	LATEST="http://raine.github.io/ramda-json-docs/latest.json"
	DOCS_URL="http://ramdajs.com/docs/"

	json=$(curl -s $LATEST)
	functions=$(echo "$json" \| jq -r '.[] \| if .sig and (.sig \| length > 0) then .name + " :: " + .sig else .name end')

	// Promise.all is good for executing many promises at once
	Promise.all([
	promise1,
	promise2
	]);

	// Promise.resolve is good for wrapping synchronous code
	Promise.resolve().then(function () {
	if (somethingIsNotRight()) {
	throw new Error("I will be rejected asynchronously!");

	/* bling.js */
	window.$ = document.querySelector.bind(document);
	window.$$ = document.querySelectorAll.bind(document);
	Node.prototype.on = window.on = function(name, fn) { this.addEventListener(name, fn); };
	NodeList.prototype.__proto__ = Array.prototype;
	NodeList.prototype.on = function(name, fn) { this.forEach((elem) => elem.on(name, fn)); };

	var through = require('through'),
	path = require('path'),
	nunjucks = require('nunjucks'),
	appRootPath = require('app-root-path').path,
	_ = require('underscore');

	var getTemplateReg = /env\.getTemplate\(("(.*?)")/g;

	/**
	* Calculates the templates path relative to the app root path.