@dillonkearns/elm-graphql/examples/src/subscription/node_modules/flow-static-land/lib/Free.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
});
exports.inj = inj;
exports.prj = prj;
exports.of = of;
exports.suspend = suspend;
exports.liftFree = liftFree;
exports.foldFree = foldFree;
exports.freeMonad = freeMonad;

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

var _Data3 = require('./Data');

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

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

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

// we can think of a free monad as just being a list of functors

var Suspend = function (_Data) {
  _inherits(Suspend, _Data);

  function Suspend() {
    _classCallCheck(this, Suspend);

    return _possibleConstructorReturn(this, (Suspend.__proto__ || Object.getPrototypeOf(Suspend)).apply(this, arguments));
  }

  return Suspend;
}(_Data3.Data1);

var Return = function (_Data2) {
  _inherits(Return, _Data2);

  function Return() {
    _classCallCheck(this, Return);

    return _possibleConstructorReturn(this, (Return.__proto__ || Object.getPrototypeOf(Return)).apply(this, arguments));
  }

  return Return;
}(_Data3.Data1);

function inj(f) {
  return f;
}

function prj(fa) {
  return fa;
}

function of(a) {
  return inj(new Return(a));
}

function suspend(ffa) {
  return inj(new Suspend(ffa));
}

function liftFree(functor, fa) {
  return suspend(functor.map(of, fa));
}

function foldFree(functor, join, ffa) {
  var fa = prj(ffa);
  if (fa instanceof Return) {
    return fa.value0;
  }
  return join(functor.map(function (x) {
    return foldFree(functor, join, x);
  }, fa.value0));
}

function freeMonad(functor) {

  function map(f, fa) {
    var a = prj(fa);
    if (a instanceof Return) {
      return of(f(a.value0));
    }
    return suspend(functor.map(function (x) {
      return map(f, x);
    }, a.value0));
  }

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

  function join(ffa) {
    var fa = prj(ffa);
    if (fa instanceof Return) {
      return fa.value0;
    }
    return suspend(functor.map(join, fa.value0));
  }

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

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