Nick Fargo nickfargo

Goal

Define a pass-through process, which conveys data directly over its I/O channels, such that the process itself is effectively an unbuffered logical channel.

Solution

This can be expressed with a standard ES6 generator function, or equivalently by defining a concrete manual iterator class.

The bits of channel state

Definitions

The most pertinent aspects of a Channel’s state can be described in terms of five bits:

CLOSED = 0x10
EMPTY = 0x08

In response to https://gist.github.com/AdrianRossouw/0d6d49702a64e22b7541

application.js

Backbone = require 'backbone'
state = require 'state'
Router = require './router'

Channel

class Channel
  constructor: ( @bufferSize = 0 ) ->
    @values = []
    @blockedSenders = null
    @blockedReceivers = null

  state @::, 'abstract',
    noSuchMethod: ( name ) ->

runtime

deprecated

Creates iterators with per-instance next methods that close over the private iterator state variables. Safer, but slower, compared to the current classical model.

{ slice } = Array::

operators = require './operators'



module.exports =

Sequence

Transformers

mapping

“Remove stickers”

mapping = ( map ) -> ( reductor ) -> ( result, input ) ->
  reductor result, map input

	# ES6
	async = (generator) ->
	g = (args..., callback) ->
	try callback null, yield receive go generator, args
	catch error then callback error
	return
	(_) -> proc g, arguments; return

	# ES5
	async = do ->

	let _ = new WeakMap;

	export default {
	init: function (obj, map = {}) {
	_.set(obj, map);
	},
	get: function (obj, key) {
	return _.get(obj)[key];
	},
	set: function (obj, key, value) {

	(defn filter
	([predicate]
	(fn [reducing-function]
	(fn
	([] (reducing-function))
	([accumulation] (reducing-function accumulation))
	([accumulation input]
	(if (predicate input)
	(reducing-function accumulation input)
	accumulation)))))