@functional-lib/irrigation/dist/Irrigation.js

irrigation fp

"use strict";

var _daggy = require("daggy");

var _fantasyLand = require("fantasy-land");

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

var Irrigation = (0, _daggy.taggedSum)('Irrigation', {
  Cons: ['head', 'tail'],
  Nil: []
});

Irrigation.from = function (xs) {
  return xs.reduceRight(function (acc, x) {
    return Irrigation.Cons(x, acc);
  }, Irrigation.Nil);
};

Irrigation[_fantasyLand.empty] = Irrigation.empty = function () {
  return Irrigation.from([]);
};

Irrigation.prototype[_fantasyLand.lte] = Irrigation.prototype.lte = function (that) {
  return +new Date(this.head.date) < +new Date(that.date);
};

Irrigation.prototype.eq = function (that) {
  return +new Date(this.head.date) === +new Date(that.date);
};

Irrigation.prototype[_fantasyLand.concat] = Irrigation.prototype.concat = function (that) {
  var _this = this;

  return this.cata({
    Cons: function Cons(head, tail) {
      return tail.is && that.head ? Irrigation.Cons(head, Irrigation.Cons(that.head, that.tail)) : Irrigation.Cons(head, !that.is ? tail.concat(that) : tail);
    },
    Nil: function Nil() {
      return _this;
    }
  });
};

Irrigation.prototype[_fantasyLand.equals] = Irrigation.prototype.equals = function (that) {
  return this.cata({
    Cons: function Cons(head, tail) {
      return that.cata({
        Cons: function Cons(head_, tail_) {
          return +new Date(head.date) === +new Date(head_.date) ? tail.equals(tail_) : +new Date(head.date) === +new Date(head_.date);
        },
        Nil: function Nil() {
          return false;
        }
      });
    },
    Nil: function Nil() {
      return true;
    }
  });
};

Irrigation.prototype.swap = function () {
  var _this2 = this;

  return this.cata({
    Cons: function Cons(head, tail) {
      var _tail$cata = tail.cata({
        Cons: function Cons(head_, tail_) {
          return {
            head_: head_,
            tail_: tail_
          };
        },
        Nil: function Nil() {
          return _this2;
        }
      }),
          head_ = _tail$cata.head_,
          tail_ = _tail$cata.tail_;

      if (!tail.is && tail.lte(head)) {
        tail = tail_;
        return Irrigation.Cons(Object.assign({}, head_), Irrigation.Cons(Object.assign({}, head), tail).swap());
      }

      return Irrigation.Cons(Object.assign({}, head), tail.swap());
    },
    Nil: function Nil() {
      return _this2;
    }
  });
};

Irrigation.prototype.sort = function () {
  var sortedIrrigation;
  var cons = this;

  Irrigation.prototype.sorting = function (_cons) {
    var _this3 = this;

    return this.cata({
      Cons: function Cons(head, tail) {
        sortedIrrigation = cons = cons.swap();
        tail.sorting(cons);
        return sortedIrrigation;
      },
      Nil: function Nil() {
        return _this3;
      }
    });
  };

  return this.sorting(this);
};

Irrigation.prototype[_fantasyLand.map] = Irrigation.prototype.map = function (f) {
  var _this4 = this;

  return this.cata({
    Cons: function Cons(head, tail) {
      return Irrigation.Cons(f(Object.assign({}, head)), tail.map(f));
    },
    Nil: function Nil() {
      return _this4;
    }
  });
};

Irrigation.prototype[_fantasyLand.filter] = Irrigation.prototype.filter = function (f) {
  return this.cata({
    Cons: function Cons(head, tail) {
      return !f(head) ? tail.filter(f) : Irrigation.Cons(head, tail.filter(f));
    },
    Nil: function Nil() {
      return Irrigation.Nil;
    }
  });
};

Irrigation.prototype.contains = function (f) {
  return this.cata({
    Cons: function Cons(head, tail) {
      if (f(head)) return true;
      Irrigation.Cons(head, tail.contains(f));
      return false;
    },
    Nil: function Nil() {
      return [];
    }
  });
};

Irrigation.prototype.toArray = function () {
  return this.cata({
    Cons: function Cons(x, acc) {
      return [x].concat(_toConsumableArray(acc.toArray()));
    },
    Nil: function Nil() {
      return [];
    }
  });
};

module.exports = Irrigation;
//# sourceMappingURL=Irrigation.js.map