JSFiddle - React, Tailwind, and code Playground

by dimitrs_papadimitriou

JavaScript

var demo = function () {

  var Identity = v => ({ value: v, map: f => Identity(f(v)) });
  var pair = (f, g) => r => a => b => f(a).map(r).map(c => g(b).map(c));
  var pairingResult = pair(Identity, Identity)(a => b => a * b)(2)(3);

  var PureF = (x) => ({
      x: x,
      map: g => PureF(g(x)),
      pair: (f, c) => f(c.a)(x),
  });

  var FreeF = (fx) => ({
      fx: fx,
      map: g => FreeF(fx.map(x => x.map(g))),
      pair: (f, c) => fx.map(x => x.pair(f, c.cofin())).value
  });

  var CoFreeF = (a, cofin) => ({
      a: a,
      cofin: cofin,
      extract: () => a,
      map: g => CoFreeF(g(a), () => cofin().map(g)),
  });


  var anaC = n => CoFreeF(n + 1, () => anaC(n + 1))

  var stream = anaC(0);

  // var freeC = CoFreeF(2, ()=>CoFreeF(5, ()=>Identity(7)));
  //var freeM = FreeF(id(FreeF(id(PureF(3)))));

  var freeM1 = PureF(0);
  var freeM2 = FreeF(Identity(PureF(0)));
  var freeM3 = FreeF(Identity(FreeF(Identity(PureF(0)))));

  var pairingResult1 = freeM1.pair(a => b => a + b, stream);
  var pairingResult2 = freeM2.pair(a => b => a + b, stream);
  var pairingResult3 = freeM3.pair(a => b => a + b, stream);


}



module.exports = demo;



// const Coyoneda = (x, f) => ({
//   x: x,
//   f: f,
//   map: g => Coyoneda(x, x => g(f(x))),
//   lower: () => f(x)
// });

// Coyoneda.lift = x => Coyoneda(x, x => x);

// var PureF = x => ({
//   x: x,
//   map: g => PureF(g(x)),
//   bind: g => g(x)
// });

// var FreeF = fx => ({
//   fx: fx,
//   map: g => FreeF(fx.map(x => x.map(g))),
//   bind: g => FreeF(fx.map(x => x.bind(g)))
// });

// var liftF = command => FreeF(command.map(PureF));
// var res = liftF(Coyoneda.lift(5)).map(x => x * 2);

// console.log(res.map(s => s.lower()));

// var monoidAdd = { empty: 0, multiply: (a, b) => a + b };
// var monoidList = { empty: [], multiply: (a, b) => a.concat(b) };
// var monoidFreeM = { empty: PureF, multiply: (a, b) => a.bind(b) };

// var id = x => PureF(x);

// var kleisli = (f, g) => x =>...