@dillonkearns/elm-graphql/examples/src/subscription/node_modules/flow-static-land/lib/Writer.js

<img src="https://cdn.jsdelivr.net/gh/martimatix/logo-graphqelm/logo.svg" alt="dillonearns/elm-graphql logo" width="40%" align="right">

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

exports.inj = inj;
exports.prj = prj;
exports.runWriter = runWriter;
exports.evalWriter = evalWriter;
exports.execWriter = execWriter;
exports.writer = writer;
exports.injWriter = injWriter;
exports.tell = tell;
exports.monadWriter = monadWriter;

var _HKT = require('./HKT');

var _Tuple = require('./Tuple');

var tuple = _interopRequireWildcard(_Tuple);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/*

  Example

  import type { Writer } from '../Writer'
  import * as writer from '../Writer'

  const stringMonoid = {
    empty: () => '',
    concat: (a, b) => [a, b].filter(Boolean).join(',')
  }

  function logNumber(n: number): Writer<string, number> {
    return writer.injWriter(n, 'Got number: ' + n)
  }

  function multWithLog(): Writer<string, number> {
    const a = logNumber(3)
    const b = logNumber(5)
    const m = writer.monadWriter(stringMonoid)
    return m.chain(a => {
      return m.chain(b => m.of(a * b), b)
    }, a)
  }

  writer.runWriter(multWithLog()) // => [15, "Got number: 3, Got number: 5, "]

*/

var IsWriter = function IsWriter() {
  _classCallCheck(this, IsWriter);
};

function inj(a) {
  return a;
}

function prj(fa) {
  return fa;
}

function runWriter(w) {
  return prj(w)();
}

function evalWriter(w) {
  return tuple.fst(runWriter(w));
}

function execWriter(w) {
  return tuple.snd(runWriter(w));
}

function writer(t) {
  return inj(function () {
    return t;
  });
}

function injWriter(a, w) {
  return writer(tuple.inj([a, w]));
}

function tell(w) {
  return inj(function () {
    return tuple.inj([undefined, w]);
  });
}

// TODO: change to getMonad
function monadWriter(monoid) {

  function map(f, fa) {
    return inj(function () {
      var _tuple$prj = tuple.prj(runWriter(fa)),
          _tuple$prj2 = _slicedToArray(_tuple$prj, 2),
          a = _tuple$prj2[0],
          w = _tuple$prj2[1];

      return tuple.inj([f(a), w]);
    });
  }

  function ap(fab, fa) {
    return chain(function (f) {
      return map(f, fa);
    }, fab); // <= derived
  }

  function of(a) {
    return inj(function () {
      return tuple.inj([a, monoid.empty()]);
    });
  }

  function chain(f, fa) {
    return inj(function () {
      var _tuple$prj3 = tuple.prj(runWriter(fa)),
          _tuple$prj4 = _slicedToArray(_tuple$prj3, 2),
          a = _tuple$prj4[0],
          w1 = _tuple$prj4[1];

      var _tuple$prj5 = tuple.prj(runWriter(f(a))),
          _tuple$prj6 = _slicedToArray(_tuple$prj5, 2),
          b = _tuple$prj6[0],
          w2 = _tuple$prj6[1];

      return tuple.inj([b, monoid.concat(w1, w2)]);
    });
  }

  return {
    map: map,
    ap: ap,
    of: of,
    chain: chain
  };
}