dinocarl

type Predicate<T> = (val: T) => boolean;
type Mapper<T, R> = (val: T) => R;
type CondTuple<T, R> = [Predicate<T>, Mapper<T, R>];

function cond<T, R>(clauses: CondTuple<T, R>[] = []) {
	const [[pred, mapr] = [undefined, undefined], ...rest] = clauses;

	return (val: T): R | undefined => {
		// base case: pred is undefined - exit the recursion
		if (pred === undefined || mapr === undefined) {

dinocarl

type Predicate<T> = (value: T) => boolean;
type Mapper<T, R> = (value: T) => R;
type CondPair<T, R> = [Predicate<T>, Mapper<T, R>];

// recursive cond that can breaks early or returns undefined
const cond = <T, R>(
  [[pred, mapr] = [] as unknown as CondPair<T, R>, ...rest]: CondPair<T, R>[] = []
): ((val: T) => R | undefined) => (val: T): R | undefined =>
  !pred ? undefined :
  pred(val) ? mapr(val) : cond(rest)(val);

dinocarl

const recMerge = (objA, objB) => Object.entries(objB).reduce(
  (acc, [key, val]) => Object.assign(
    {},
    objA,
    { [key]: is(Object, val) ? recMerge(objA[key], val) : val }
  ),
  {}
);

dinocarl

const strongOrPlain = (bool, str) => bool
  ? `<strong>${str}</strong>`
  : str;

const RangeItemComp = ({header, start, end, highlighted}) => `<li>${
  strongOrPlain(
    highlighted,
    `${header}: ${start} - ${end}`
  )}</li>`;

dinocarl

const S  = f => g => x => f (x) (g (x));
const S2 = f => g => h => x => f (g (x)) (h (x));

// create a list based on a list of numbers that won't
// contain a zero, where the result is a list of products
// of the list without the number at the position of a given member
// eg [5,2,1,4,3] => [24, 60, 120, 30, 40]

// the key is that the computed product of the list and
// then divided by a given member, is equivalent to

dinocarl

const assocPth = ([head, ...rest], value, obj) => Array.isArray(obj)
  ? [].concat(
    obj.slice(0, head),
    [rest.length
      ? assocPth(rest, value, obj[head])
      : value],
    obj.slice(head + 1))
  : Object.assign({},
    obj,
    {[head]: rest.length

dinocarl

const data = [
  { label: 'first', val: 'gold-like' },
  { label: 'second', val: 'silver-esque' },
  { label: 'third', val: 'bronz-ish' },
];

const propLen = (propName) => compose(
  length,
  propOr('', propName)
);

dinocarl

// permitted actions for state changes
const eventActions = {
  write: (path, val = null) => assocPath(path, val),
  erase: (path) => dissocPath(path),
};

const noop = () => () => {};

// run a legitmate action on a state object
const eventToState = ({ type, path, val }, stateObj, actions) => propOr(

dinocarl

const formula = 
  {'+': [
    2, 2, 3,
    {'-': [
      5,
      {'+': [
        2, {'var': 'base-val'}, {var: 'base'},
        {'+': [
          1,
          {'*': [

dinocarl

const dot = (f, g) => a => f(g(a));

const cmp = reduce(dot, identity);

const cmp2 = reduce(o, identity);

[
  compose(
    sum,
    range(2),