123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
import { assertIsDefined, assertIsEquivalent, assertIsNone } from "./asserts.js";import { factorizeSumType } from "./SumType.js";
const $$value = Symbol.for("TypeValue");
export const Maybe = factorizeSumType(  "Maybe",  {    Nothing: [],    Just: [ $$value ]  });
Maybe.fromNullable = value => !assertIsDefined(value) || assertIsNone(value) ? Maybe.nothing() : Maybe.just(value);Maybe.just = value => Maybe.Just(value);Maybe.nothing = () => Maybe.Nothing;Maybe.of = value => Maybe.Just(value);
// alt :: Maybe a ~> Maybe a -> Maybe aMaybe.prototype.alt = Maybe.prototype["fantasy-land/alt"] = function (container) {
  return this.fold({    Just: _ => this,    Nothing: _ => container  });};
// ap :: Maybe a ~> m (a -> b) -> Maybe bMaybe.prototype.ap = Maybe.prototype["fantasy-land/ap"] = function (container) {  if (Maybe.Nothing.is(this)) return this;
  return container.fold({    Just: _ => Maybe.of(container[$$value](this[$$value])),    Nothing: _ => container  });};
// chain :: Maybe a ~> (a -> Maybe b) -> Maybe bMaybe.prototype.chain = Maybe.prototype["fantasy-land/chain"] = function (composedFunction) {
  return this.fold({    Just: value => composedFunction(value),    Nothing: _ => Maybe.Nothing  });};
// filter :: Maybe a ~> (a -> Boolean) -> Maybe aMaybe.prototype.filter = Maybe.prototype["fantasy-land/filter"] = function (predicate) {
  return this.fold({    Just: _ => predicate(this[$$value]) ? this : Maybe.Nothing,    Nothing: _ => this  });};
// map :: Maybe a ~> (a -> b) -> Maybe bMaybe.prototype.map = Maybe.prototype["fantasy-land/map"] = function (composedFunction) {
  // return this.chain(container => Maybe.of(composedFunction(container)));  return this.fold({    Just: _ => Maybe.of(composedFunction(this[$$value])),    Nothing: _ => this  });};
// reduce :: Maybe a ~> ((b, a) -> b, b) -> bMaybe.prototype.reduce = Maybe.prototype["fantasy-land/reduce"] = function (composedFunction, accumulator) {
  return this.fold({    Just: _ => composedFunction(accumulator, this[$$value]),    Nothing: _ => accumulator  });};
Maybe.prototype.sequence = Maybe.prototype["fantasy-land/sequence"] = function (TypeRep) {
  return this.traverse(TypeRep, x => x);};
// traverse :: Applicative f, Traversable t => t a ~> (TypeRep f, a -> f b) -> f (t b)Maybe.prototype.traverse = function (TypeRep, composedFunction) {
  return this.fold({    Just: _ => composedFunction(this[$$value]).map(Maybe.of),    Nothing: _ => TypeRep.of(this)  });};
Deno.test(  "Maybe: #just",  () =>      assertIsEquivalent(Maybe.just(42), Maybe.Just(42)));
Deno.test(  "Maybe.Just: #alt",  () =>    assertIsEquivalent(      Maybe.Just(42).alt(Maybe.Just(24)),      Maybe.Just(42)    ));
Deno.test(  "Maybe.Just: #ap - Composition",  () => {    const containerA = Maybe.Just(42);    const containerB = Maybe.Just(x => x + 2);    const containerC = Maybe.Just(x => x * 2);
    assertIsEquivalent(      containerA.ap(containerB.ap(containerC.map(a => b => c => a(b(c))))),      containerA.ap(containerB).ap(containerC)    );  });
Deno.test(  "Maybe.Just: #ap with either",  () => {    const lift2 = (f, a, b) => b.ap(a.map(f));    const either = (x, y) => lift2(a => b => a || b, x, y);
    assertIsEquivalent(      either(        Maybe.Just(false),        Maybe.Just(82)      ),      Maybe.Just(82)    );  });
Deno.test(  "Maybe.Just: #ap with lift",  () => {    const lift2 = (f, a, b) => b.ap(a.map(f));
    const containerA = Maybe.Just(42);    const containerB = Maybe.Just(32);
    assertIsEquivalent(      lift2(x => y => x * y, containerA, containerB),      Maybe.Just(1344)    );  });
Deno.test(  "Maybe.Just: #ap with merge",  () => {    const append = y => xs => xs.concat([y]);    const lift2 = (f, a, b) => b.ap(a.map(f));    const merge = (T, xs) => xs.reduce(      (acc, x) => lift2(append, x, acc),      T.of([])    );
    assertIsEquivalent(      merge(        Maybe,        [          Maybe.Just(2),          Maybe.Just(10),          Maybe.Just(3)        ]      ),      Maybe.Just([ 2, 10, 3 ])    );  });
Deno.test(  "Maybe.Just: #filter (even)",  () =>    assertIsEquivalent(      Maybe.Just(42).filter(x => x % 2 === 0),      Maybe.Just(42)    ));
Deno.test(  "Maybe.Just: #filter (odd)",  () =>    assertIsEquivalent(      Maybe.Just(23).filter(x => x % 2 === 0),      Maybe.Nothing    ));
Deno.test(  "Maybe.Just: #map",  () =>    assertIsEquivalent(      Maybe.Just(42).map(x => x * 2),      Maybe.Just(84)    ));
Deno.test(  "Maybe.Just: #map - Identity",  () => {    const container = Maybe.Just(42);
    assertIsEquivalent(      container.map(x => x),      container    );  });
Deno.test(  "Maybe.Just: #map - Composition",  () => {    const container = Maybe.Just(42);    const f = x => x + 2;    const g = x => x * 2;
    assertIsEquivalent(      container.map(f).map(g),      container.map(x => g(f(x)))    );  });
Deno.test(  "Maybe.Nothing: #alt",  () =>    assertIsEquivalent(      Maybe.Nothing.alt(Maybe.Just(42)),      Maybe.Just(42)    ));
Deno.test(  "Maybe.Nothing: #filter",  () =>    assertIsEquivalent(      Maybe.Nothing.filter(x => x % 2 === 0),      Maybe.Nothing    ));
Deno.test(  "Maybe.Nothing: #map",  () =>    assertIsEquivalent(      Maybe.Nothing.map(x => x * 2),      Maybe.Nothing    ));
Deno.test(  "Maybe.Nothing: #map - Identity",  () => {    const container = Maybe.Nothing;
    assertIsEquivalent(      container.map(x => x),      container    );  });
Deno.test(  "Maybe.Nothing: #map - Composition",  () => {    const container = Maybe.Nothing;    const f = x => x + 2;    const g = x => x * 2;
    assertIsEquivalent(      container.map(f).map(g),      container.map(x => g(f(x)))    );  });
export default Maybe;