gmmorris

const isObject = obj => obj && typeof obj === 'object';
const hasKey = (obj, key) => key in obj;

const Undefined = new Proxy({}, {
    get: function(target, name){
        return Undefined;
    }
  });
const either = (val,fallback) => (val === Undefined? fallback : val);

gmmorris

const DarthVader = {
  name : 'Anakin',
  mother : {
    name : 'Shmi'
  }
}

function getFatherName(person) {
  return person.father.name
}

gmmorris

const isFunction = fn => typeof fn === 'function'
const isNumber = n => typeof n === 'number' && !isNaN(n)

function createFunctionPipe({ interval, fn, args = [] } = {}) {  
  if(!isFunction(fn)){
    throw Error('Invalid callback (fn) argument');
  }
  
  if(isNumber(interval)) {
    return setTimeout(() => fn(...args), interval);

gmmorris

/*
 * A Higher Order Function which takes a Class definition and returns a new function.
 *
 * @param  {Function} ClassToCompose  The class definition we wish to analyze
 * @return {Function} A function which takes a property name and return a boolean specifying whether
 *                    the class has a method with that name which is composable
*/
function isComposablePropertyOf(ClassToCompose) {
  const proto = ClassToCompose.prototype;
  return propertyName => {

gmmorris

export default function(methodComposer) {
  return ClassToCompose => {
    class ComposedClass extends ClassToCompose {
      constructor() {
        super(...arguments);
      }
    }

    const baseProto = ClassToCompose.prototype;

gmmorris

export default function(methodComposer) {
  return ClassToCompose => {
    const proto = ClassToCompose.prototype;
    return class extends ClassToCompose {
      constructor() {
        super(...arguments);
        for (const prop of Object.getOwnPropertyNames(proto)) {
          const method = proto[prop];
          const {configurable, writable} = Object.getOwnPropertyDescriptor(proto, prop);

gmmorris

function MyConstructor() {
}

// meant to be called this way:
var myInstance = new MyConstructor();

// but could also be called, usually incorrectly, this way
var myInstance = MyConstructor();

gmmorris

const FactorySentinal = Symbol('ClassFactory');
export function isFactory(SupposedFactory) {
  return SupposedFactory && SupposedFactory[FactorySentinal];
}

export default function(methodComposer) {
  return ClassToCompose => {
    const proto = ClassToCompose.prototype;
    function factory() {
      const instance = new ClassToCompose(...arguments);

gmmorris

// Our higher order function which logs all returned values to the function properties on an object
function attachLogger(objectOrFunction) {
  if(typeof objectOrFunction === 'function'){
    return function() {
      let ret = objectOrFunction.apply(this, arguments);
      console.log(ret);
      return ret;
    }
  }
  

gmmorris

// Our higher order function which converts pennies to pounds (£) (or cents to dollars, for that matter)
function convertPenniesToPounds(priceFunction) {
  return function() {
    return priceFunction.apply(this, arguments)/100;
  }
}

// we have component which fetches a price in pennies
const PriceFetcher = {
  getPriceInPence : function(productId) {