JSFiddle - React, Tailwind, and code Playground

by dimitrs_papadimitriou

JavaScript

var t = State.of(x => y => x.concat(y))
  .app(State(s => [[5], s + 5]))
  .app(State(s => [[5], s + 1]))
  .runState(0);

var templateDetails = reader(client => `<div> ${client.name}</div>`);

var templateList = s => content => `${s}${content}`;
var
var t = templateDetails.map(templateList).run({ id: 1, name: "i_", age: 25 });

var f = x => {
  return State(s => [x, templateDetails.map(templateList(s)).run(x)]);
};

var rr = traverse(
  [{ id: 1, name: "i1", age: 25 }, { id: 1, name: "i2", age: 25 }],
  State.of,
  f
);
console.log(rr.runState("")[1]);

var template = client => `<div> ${client.name}</div>`;

var reder = [
  { id: 1, name: "i1", age: 25 },
  { id: 1, name: "i2", age: 25 }
].reduce((a, e) => templateList(a)(template(e)),"")
//////////////
var WriterM = m => (l, x) => ({
  l: l,
  x: x,
  map: f => WriterM(m)(l, f(x)),
  chain: f => {
    var r = f(x);
    return WriterM(m)(m.concat(r.l, l), r.x);
  },
  app: fa => {
    var r = x(fa.x);
    return WriterM(m)(m.concat(fa.l, l), r);
  },

  cata: alg => {
    alg.l(l);
    alg.x(x);
  }
});

var Writer = WriterM({ concat: (x, y) => x.concat(y) });

Writer.of = x => Writer(x, x);

// Writer.of(x=>x+1).app(Writer(5,5))
// .cata({
//   l: a => console.log("log: " + a),
//   x: a => console.log("value :" + a)
// });

// var chain = Writer(1, 2)
//   .chain(x => Writer(1, x + 2))
//   .cata({
//     l: a => console.log("log" + a),
//     x: a => console.log("value " + a)
//   });

var traverse = function(list, TyperRep, f) {
  if (list.length === 0) {
    return TyperRep([]);
  } else {
    var head = list.shift();
    return TyperRep(x => y => x.concat(y))
      .app(f(head).map(x => [x]))
      .app(traverse(list, TyperRep, f));
  }
};

var rr = traverse([2, 3, 5], x => Writer([], x), x => Writer([x] , x));
console.log(rr);
////////////

const State = st => ({
  runState: x => st(x),
  map: f =>
    State(x => {
      const [a, ss] = st(x);
      return [f(a), ss];
    }),
  chain: f =>
    State(s =>...