monoid.ts

export {}
// A monoid is a binary associative operation with an identity

// Laws
// 1 - Associativity: (x <> y) <> z = x <> (y <> z)
// 2 - Left identity: mempty <> x = x
// 3 - Right identity: x <> mempty = x

type Monoid<A = any> = {
  mempty: A,
  mappend: (x: A, y: A) => A
}

//** Sum Monoid */
type NumberSumWrapper = {
  val: number;
}

const NumberSum: Monoid<NumberSumWrapper> = {
  mempty: { val: 0 },
  mappend: (x, y) => ({ val: x.val + y.val })
}

//** List Monoid */
const List: Monoid<Array<any>> = {
  mempty: [],
  mappend: (lst1, lst2) => lst1.concat(lst2)
}




const runLaws = <T>(
  monoid: Monoid,
  set1: T,
  set2: T,
  set3: T
) => {
  // 1- Associativity
  const assoc1 = monoid.mappend( monoid.mappend(set1, set2), set3 );
  const assoc2 = monoid.mappend( set1, monoid.mappend(set2, set3) );
  console.log(`${JSON.stringify(assoc1)} === ${JSON.stringify(assoc2)}`)

  // 2- Left identity
  const concrete = set3;
  const lId = monoid.mappend(monoid.mempty, concrete);
  console.log(`${JSON.stringify(lId)} === ${JSON.stringify(concrete)}`);

  // 2- Right identity
  const rId = monoid.mappend(concrete, monoid.mempty);
  console.log(`${JSON.stringify(concrete)} === ${JSON.stringify(rId)}`);
}

runLaws<NumberSumWrapper>(NumberSum, { val: 1 }, { val: 2 }, { val: 3 });
runLaws<Array<number>>(List, [1, 2], [3, 4], [5, 6, 7]);