TGOlson

import Data.Monoid
import Data.Maybe
import Data.List


data Finder a = Finder ([a] -> Maybe a)


instance Monoid (Finder a) where
  mempty = Finder (const Nothing)

TGOlson

/*
 * Generate migration file:
 * $ gulp create-migration --name update-tenant-auth-connectors
 */
 
// Define migration
var systemService = require('<systemService>'),
    systemTenant = systemService.systemTenant;

exports.up = Scaffold.defineMigration(function() {

TGOlson

var R = require('ramda');

var rpn = R.compose(R.head, R.reduce(foldingFn, []), R.split(' '));

function foldingFn(acc, v) {
  if(isOperator(v)) {
    var vs   = R.take(2, acc),
        rest = R.drop(2, acc);

    return R.prepend(useOperator(v, vs), rest);

TGOlson

data List a = Empty | Cons a (List a) deriving (Eq)


instance Show a => Show (List a) where
  show list = "(" ++ showListContents list ++ ")"


showListContents :: Show a => List a -> String
showListContents Empty = ""
showListContents (Cons x Empty) = show x

TGOlson

'use strict';

var R = require('ramda');


var extract = R.invoke('extract', []);


var makeMonoid = R.curry(function(identity, binary, v) {

TGOlson

'use strict';

// All (||) operator as a monoid

function All(v) {
  return {
    value: v
  };
}

TGOlson

'use strict';

// Or (||) operator as a monoid

function Or(v) {
  return {
    value: v
  };
}

TGOlson

/**
 * Data Type
 */
// Tree a = EmptyTree | Node a (Tree a) (Tree a)


/**
 * Value Constructors
 */

TGOlson

function PropertyGetterFactory(value) {
  return {
    get: function(prop) {
      return mapToPropertyGetter(partial(get, prop), value);
    },
    map: function(callback) {
      return mapToPropertyGetter(callback, value);
    },
    unwrap: always(value)
  };

TGOlson

var R = require('ramda');

// [k] -> {k: a, load: fn} -> a
var getPath = R.curry(function(propList, entity) {
  return getPathFromPropList(propList, entity);
});

var getPathFromPropList = R.curry(function(propList, entity) {
  var loadPattern = convertPropListToLoadPattern(propList);