ortense

const stack = (...values) =>  
  Object.create({
    get: index => values[index],
    add: value => stack(...[value].concat(values)),
    remove: () => stack(...values.slice(1)),
    toString: () => `stack [${values.join(' ')}]`,
    toArray: () => values.slice(0),
    get length() { return values.length },
    constructor: stack
  })

ortense

const memoize = fn => {
  const memo = {}
  
  return (...args) => {
    if (args in memo) return memo[args]
    return (memo[args] = fn.apply(null, args))
  }
}

ortense

const pipe = (...fns) => arg => 
  fns.reduce((acc, fn) => fn(acc), arg)

/*
const a = x => `a(${x})`
const b = x => `b(${x})`
const c = x => `c(${x})`

const piped = compose(a, b, c) 

ortense

const compose = (...fns) => 
  fns.reduce((f, g) => (...args) => f(g(...args)))

/*
const a = x => `a(${x})`
const b = x => `b(${x})`
const c = x => `c(${x})`

const composed = compose(a, b, c) 
composed('x') // a(b(c(x)))

ortense

var pubsub = {};
(function(q) {
    var topics = {}, subUid = -1;
    q.subscribe = function(topic, func) {
        if (!topics[topic]) {
            topics[topic] = [];
        }
        var token = (++subUid).toString();
        topics[topic].push({
            token: token,

ortense

const lower = str => str.toLowerCase()

const upper = str => str.toUpperCase()

const trim = str => str.trim()

const exclaim = str => `${str}!!`

const string = str => ({
    get upper() { return string(upper(str)) },

ortense

const curry = (fn, ...args) => {
  if (args.length === fn.length) return fn(...args)
  return (...more) => curry(fn, ...args, ...more)
}

/*
const add = (a, b, c) => a + b + c

const curred = curry(add)

ortense

const propertyDescriptor = { enumerable: true, writable: false }

export default class CustomError extends Error {
  constructor(message) {
    super(message)

    this.type = this.constructor.name
    Object.defineProperty(this, 'type', propertyDescriptor)
    Object.defineProperty(this, 'message', propertyDescriptor)
  }

ortense

{
  // http://eslint.org/docs/rules/

  "ecmaFeatures": {
    "binaryLiterals": false,                    // enable binary literals
    "blockBindings": false,                     // enable let and const (aka block bindings)
    "defaultParams": false,                     // enable default function parameters
    "forOf": false,                             // enable for-of loops
    "generators": false,                        // enable generators
    "objectLiteralComputedProperties": false,   // enable computed object literal property names

ortense

{
    "presets": ["es2015"],
    "plugins": [
        "transform-decorators-legacy",
        "transform-async-to-generator"
    ]
}