@explorable-viz/fluid 0.12.3 → 0.12.5

package/output-es/Data.DateTime.Instant/index.js

@@ -0,0 +1,86 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dDate from "../Data.Date/index.js";
+import * as Data$dDate$dComponent from "../Data.Date.Component/index.js";
+import * as Data$dDateTime from "../Data.DateTime/index.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dTime from "../Data.Time/index.js";
+import {fromDateTimeImpl, toDateTimeImpl} from "./foreign.js";
+const unInstant = v => v;
+const toDateTime = /* #__PURE__ */ toDateTimeImpl(y => mo => d => h => mi => s => ms => Data$dDateTime.$DateTime(
+  Data$dDate.canonicalDate(y)((() => {
+    if (mo === 1) { return Data$dDate$dComponent.January; }
+    if (mo === 2) { return Data$dDate$dComponent.February; }
+    if (mo === 3) { return Data$dDate$dComponent.March; }
+    if (mo === 4) { return Data$dDate$dComponent.April; }
+    if (mo === 5) { return Data$dDate$dComponent.May; }
+    if (mo === 6) { return Data$dDate$dComponent.June; }
+    if (mo === 7) { return Data$dDate$dComponent.July; }
+    if (mo === 8) { return Data$dDate$dComponent.August; }
+    if (mo === 9) { return Data$dDate$dComponent.September; }
+    if (mo === 10) { return Data$dDate$dComponent.October; }
+    if (mo === 11) { return Data$dDate$dComponent.November; }
+    if (mo === 12) { return Data$dDate$dComponent.December; }
+    $runtime.fail();
+  })())(d),
+  Data$dTime.$Time(h, mi, s, ms)
+));
+const showInstant = {show: v => "(Instant (Milliseconds " + Data$dShow.showNumberImpl(v) + "))"};
+const ordDateTime = Data$dOrd.ordNumber;
+const instant = v => {
+  if (v >= -8639977881600000.0 && v <= 8639977881599999.0) { return Data$dMaybe.$Maybe("Just", v); }
+  return Data$dMaybe.Nothing;
+};
+const fromDateTime = v => fromDateTimeImpl(
+  v._1._1,
+  (() => {
+    if (v._1._2 === "January") { return 1; }
+    if (v._1._2 === "February") { return 2; }
+    if (v._1._2 === "March") { return 3; }
+    if (v._1._2 === "April") { return 4; }
+    if (v._1._2 === "May") { return 5; }
+    if (v._1._2 === "June") { return 6; }
+    if (v._1._2 === "July") { return 7; }
+    if (v._1._2 === "August") { return 8; }
+    if (v._1._2 === "September") { return 9; }
+    if (v._1._2 === "October") { return 10; }
+    if (v._1._2 === "November") { return 11; }
+    if (v._1._2 === "December") { return 12; }
+    $runtime.fail();
+  })(),
+  v._1._3,
+  v._2._1,
+  v._2._2,
+  v._2._3,
+  v._2._4
+);
+const fromDate = d => fromDateTimeImpl(
+  d._1,
+  (() => {
+    if (d._2 === "January") { return 1; }
+    if (d._2 === "February") { return 2; }
+    if (d._2 === "March") { return 3; }
+    if (d._2 === "April") { return 4; }
+    if (d._2 === "May") { return 5; }
+    if (d._2 === "June") { return 6; }
+    if (d._2 === "July") { return 7; }
+    if (d._2 === "August") { return 8; }
+    if (d._2 === "September") { return 9; }
+    if (d._2 === "October") { return 10; }
+    if (d._2 === "November") { return 11; }
+    if (d._2 === "December") { return 12; }
+    $runtime.fail();
+  })(),
+  d._3,
+  0,
+  0,
+  0,
+  0
+);
+const eqDateTime = Data$dEq.eqNumber;
+const diff = dictDuration => dt1 => dt2 => dictDuration.toDuration(dt1 + -dt2);
+const boundedInstant = {bottom: -8639977881600000.0, top: 8639977881599999.0, Ord0: () => Data$dOrd.ordNumber};
+export {boundedInstant, diff, eqDateTime, fromDate, fromDateTime, instant, ordDateTime, showInstant, toDateTime, unInstant};
+export * from "./foreign.js";

package/output-es/Data.Decidable/index.js

@@ -0,0 +1,70 @@
+import * as Data$dDecide from "../Data.Decide/index.js";
+import * as Data$dDivisible from "../Data.Divisible/index.js";
+const identity = x => x;
+const lose = dict => dict.lose;
+const lost = dictDecidable => dictDecidable.lose(identity);
+const decidablePredicate = {
+  lose: f => a => {
+    const spin = spin$a0$copy => {
+      let spin$a0 = spin$a0$copy, spin$c = true, spin$r;
+      while (spin$c) {
+        const v = spin$a0;
+        spin$a0 = v;
+      }
+      return spin$r;
+    };
+    return spin(f(a));
+  },
+  Decide0: () => Data$dDecide.choosePredicate,
+  Divisible1: () => Data$dDivisible.divisiblePredicate
+};
+const decidableOp = dictMonoid => {
+  const chooseOp = Data$dDecide.chooseOp(dictMonoid.Semigroup0());
+  const divisibleOp = Data$dDivisible.divisibleOp(dictMonoid);
+  return {
+    lose: f => a => {
+      const spin = spin$a0$copy => {
+        let spin$a0 = spin$a0$copy, spin$c = true, spin$r;
+        while (spin$c) {
+          const v = spin$a0;
+          spin$a0 = v;
+        }
+        return spin$r;
+      };
+      return spin(f(a));
+    },
+    Decide0: () => chooseOp,
+    Divisible1: () => divisibleOp
+  };
+};
+const decidableEquivalence = {
+  lose: f => a => {
+    const spin = spin$a0$copy => {
+      let spin$a0 = spin$a0$copy, spin$c = true, spin$r;
+      while (spin$c) {
+        const v = spin$a0;
+        spin$a0 = v;
+      }
+      return spin$r;
+    };
+    return spin(f(a));
+  },
+  Decide0: () => Data$dDecide.chooseEquivalence,
+  Divisible1: () => Data$dDivisible.divisibleEquivalence
+};
+const decidableComparison = {
+  lose: f => a => v => {
+    const spin = spin$a0$copy => {
+      let spin$a0 = spin$a0$copy, spin$c = true, spin$r;
+      while (spin$c) {
+        const v$1 = spin$a0;
+        spin$a0 = v$1;
+      }
+      return spin$r;
+    };
+    return spin(f(a));
+  },
+  Decide0: () => Data$dDecide.chooseComparison,
+  Divisible1: () => Data$dDivisible.divisibleComparison
+};
+export {decidableComparison, decidableEquivalence, decidableOp, decidablePredicate, identity, lose, lost};

package/output-es/Data.Decide/index.js

@@ -0,0 +1,64 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dDivide from "../Data.Divide/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const identity = x => x;
+const choosePredicate = {
+  choose: f => v => v1 => x => {
+    const $0 = f(x);
+    if ($0.tag === "Left") { return v($0._1); }
+    if ($0.tag === "Right") { return v1($0._1); }
+    $runtime.fail();
+  },
+  Divide0: () => Data$dDivide.dividePredicate
+};
+const chooseOp = dictSemigroup => {
+  const divideOp = Data$dDivide.divideOp(dictSemigroup);
+  return {
+    choose: f => v => v1 => x => {
+      const $0 = f(x);
+      if ($0.tag === "Left") { return v($0._1); }
+      if ($0.tag === "Right") { return v1($0._1); }
+      $runtime.fail();
+    },
+    Divide0: () => divideOp
+  };
+};
+const chooseEquivalence = {
+  choose: f => v => v1 => a => b => {
+    const v2 = f(a);
+    if (v2.tag === "Left") {
+      const v3 = f(b);
+      if (v3.tag === "Left") { return v(v2._1)(v3._1); }
+      if (v3.tag === "Right") { return false; }
+      $runtime.fail();
+    }
+    if (v2.tag === "Right") {
+      const v3 = f(b);
+      if (v3.tag === "Left") { return false; }
+      if (v3.tag === "Right") { return v1(v2._1)(v3._1); }
+    }
+    $runtime.fail();
+  },
+  Divide0: () => Data$dDivide.divideEquivalence
+};
+const chooseComparison = {
+  choose: f => v => v1 => a => b => {
+    const v2 = f(a);
+    if (v2.tag === "Left") {
+      const v3 = f(b);
+      if (v3.tag === "Left") { return v(v2._1)(v3._1); }
+      if (v3.tag === "Right") { return Data$dOrdering.LT; }
+      $runtime.fail();
+    }
+    if (v2.tag === "Right") {
+      const v3 = f(b);
+      if (v3.tag === "Left") { return Data$dOrdering.GT; }
+      if (v3.tag === "Right") { return v1(v2._1)(v3._1); }
+    }
+    $runtime.fail();
+  },
+  Divide0: () => Data$dDivide.divideComparison
+};
+const choose = dict => dict.choose;
+const chosen = dictDecide => dictDecide.choose(identity);
+export {choose, chooseComparison, chooseEquivalence, chooseOp, choosePredicate, chosen, identity};

package/output-es/Data.Distributive/index.js

@@ -0,0 +1,55 @@
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Unsafe$dCoerce from "../Unsafe.Coerce/index.js";
+const identity = x => x;
+const distributiveIdentity = {
+  distribute: dictFunctor => dictFunctor.map(Unsafe$dCoerce.unsafeCoerce),
+  collect: dictFunctor => f => dictFunctor.map(x => f(x)),
+  Functor0: () => Data$dIdentity.functorIdentity
+};
+const distribute = dict => dict.distribute;
+const distributiveFunction = {
+  distribute: dictFunctor => a => e => dictFunctor.map(v => v(e))(a),
+  collect: dictFunctor => f => {
+    const $0 = distributiveFunction.distribute(dictFunctor);
+    const $1 = dictFunctor.map(f);
+    return x => $0($1(x));
+  },
+  Functor0: () => Data$dFunctor.functorFn
+};
+const cotraverse = dictDistributive => dictFunctor => {
+  const distribute2 = dictDistributive.distribute(dictFunctor);
+  return f => {
+    const $0 = dictDistributive.Functor0().map(f);
+    return x => $0(distribute2(x));
+  };
+};
+const collectDefault = dictDistributive => dictFunctor => {
+  const distribute2 = dictDistributive.distribute(dictFunctor);
+  return f => {
+    const $0 = dictFunctor.map(f);
+    return x => distribute2($0(x));
+  };
+};
+const distributiveTuple = dictTypeEquals => {
+  const from = dictTypeEquals.proof(a => a);
+  return {
+    collect: dictFunctor => {
+      const distribute2 = distributiveTuple(dictTypeEquals).distribute(dictFunctor);
+      return f => {
+        const $0 = dictFunctor.map(f);
+        return x => distribute2($0(x));
+      };
+    },
+    distribute: dictFunctor => {
+      const $0 = Data$dTuple.Tuple(from());
+      const $1 = dictFunctor.map(Data$dTuple.snd);
+      return x => $0($1(x));
+    },
+    Functor0: () => Data$dTuple.functorTuple
+  };
+};
+const collect = dict => dict.collect;
+const distributeDefault = dictDistributive => dictFunctor => dictDistributive.collect(dictFunctor)(identity);
+export {collect, collectDefault, cotraverse, distribute, distributeDefault, distributiveFunction, distributiveIdentity, distributiveTuple, identity};

package/output-es/Data.Divide/index.js

@@ -0,0 +1,47 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dComparison from "../Data.Comparison/index.js";
+import * as Data$dEquivalence from "../Data.Equivalence/index.js";
+import * as Data$dOp from "../Data.Op/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import * as Data$dPredicate from "../Data.Predicate/index.js";
+const identity = x => x;
+const dividePredicate = {
+  divide: f => v => v1 => a => {
+    const v2 = f(a);
+    return v(v2._1) && v1(v2._2);
+  },
+  Contravariant0: () => Data$dPredicate.contravariantPredicate
+};
+const divideOp = dictSemigroup => (
+  {
+    divide: f => v => v1 => a => {
+      const v2 = f(a);
+      return dictSemigroup.append(v(v2._1))(v1(v2._2));
+    },
+    Contravariant0: () => Data$dOp.contravariantOp
+  }
+);
+const divideEquivalence = {
+  divide: f => v => v1 => a => b => {
+    const v2 = f(a);
+    const v3 = f(b);
+    return v(v2._1)(v3._1) && v1(v2._2)(v3._2);
+  },
+  Contravariant0: () => Data$dEquivalence.contravariantEquivalence
+};
+const divideComparison = {
+  divide: f => v => v1 => a => b => {
+    const v2 = f(a);
+    const v3 = f(b);
+    const $0 = v(v2._1)(v3._1);
+    const $1 = v1(v2._2)(v3._2);
+    if ($0 === "LT") { return Data$dOrdering.LT; }
+    if ($0 === "GT") { return Data$dOrdering.GT; }
+    if ($0 === "EQ") { return $1; }
+    $runtime.fail();
+  },
+  Contravariant0: () => Data$dComparison.contravariantComparison
+};
+const divide = dict => dict.divide;
+const divided = dictDivide => dictDivide.divide(identity);
+export {divide, divideComparison, divideEquivalence, divideOp, dividePredicate, divided, identity};

package/output-es/Data.Divisible/index.js

@@ -0,0 +1,17 @@
+import * as Data$dDivide from "../Data.Divide/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const divisiblePredicate = {conquer: v => true, Divide0: () => Data$dDivide.dividePredicate};
+const divisibleOp = dictMonoid => {
+  const divideOp = Data$dDivide.divideOp(dictMonoid.Semigroup0());
+  return {
+    conquer: (() => {
+      const $0 = dictMonoid.mempty;
+      return v => $0;
+    })(),
+    Divide0: () => divideOp
+  };
+};
+const divisibleEquivalence = {conquer: v => v1 => true, Divide0: () => Data$dDivide.divideEquivalence};
+const divisibleComparison = {conquer: v => v1 => Data$dOrdering.EQ, Divide0: () => Data$dDivide.divideComparison};
+const conquer = dict => dict.conquer;
+export {conquer, divisibleComparison, divisibleEquivalence, divisibleOp, divisiblePredicate};

package/output-es/Data.DivisionRing/index.js

@@ -0,0 +1,6 @@
+import * as Data$dRing from "../Data.Ring/index.js";
+const recip = dict => dict.recip;
+const rightDiv = dictDivisionRing => a => b => dictDivisionRing.Ring0().Semiring0().mul(a)(dictDivisionRing.recip(b));
+const leftDiv = dictDivisionRing => a => b => dictDivisionRing.Ring0().Semiring0().mul(dictDivisionRing.recip(b))(a);
+const divisionringNumber = {recip: x => 1.0 / x, Ring0: () => Data$dRing.ringNumber};
+export {divisionringNumber, leftDiv, recip, rightDiv};

package/output-es/Data.Either/index.js

@@ -0,0 +1,242 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dGeneric$dRep from "../Data.Generic.Rep/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+const $Either = (tag, _1) => ({tag, _1});
+const Left = value0 => $Either("Left", value0);
+const Right = value0 => $Either("Right", value0);
+const showEither = dictShow => dictShow1 => (
+  {
+    show: v => {
+      if (v.tag === "Left") { return "(Left " + dictShow.show(v._1) + ")"; }
+      if (v.tag === "Right") { return "(Right " + dictShow1.show(v._1) + ")"; }
+      $runtime.fail();
+    }
+  }
+);
+const note$p = f => v2 => {
+  if (v2.tag === "Nothing") { return $Either("Left", f()); }
+  if (v2.tag === "Just") { return $Either("Right", v2._1); }
+  $runtime.fail();
+};
+const note = a => v2 => {
+  if (v2.tag === "Nothing") { return $Either("Left", a); }
+  if (v2.tag === "Just") { return $Either("Right", v2._1); }
+  $runtime.fail();
+};
+const genericEither = {
+  to: x => {
+    if (x.tag === "Inl") { return $Either("Left", x._1); }
+    if (x.tag === "Inr") { return $Either("Right", x._1); }
+    $runtime.fail();
+  },
+  from: x => {
+    if (x.tag === "Left") { return Data$dGeneric$dRep.$Sum("Inl", x._1); }
+    if (x.tag === "Right") { return Data$dGeneric$dRep.$Sum("Inr", x._1); }
+    $runtime.fail();
+  }
+};
+const functorEither = {
+  map: f => m => {
+    if (m.tag === "Left") { return $Either("Left", m._1); }
+    if (m.tag === "Right") { return $Either("Right", f(m._1)); }
+    $runtime.fail();
+  }
+};
+const invariantEither = {
+  imap: f => v => m => {
+    if (m.tag === "Left") { return $Either("Left", m._1); }
+    if (m.tag === "Right") { return $Either("Right", f(m._1)); }
+    $runtime.fail();
+  }
+};
+const fromRight$p = v => v1 => {
+  if (v1.tag === "Right") { return v1._1; }
+  return v();
+};
+const fromRight = v => v1 => {
+  if (v1.tag === "Right") { return v1._1; }
+  return v;
+};
+const fromLeft$p = v => v1 => {
+  if (v1.tag === "Left") { return v1._1; }
+  return v();
+};
+const fromLeft = v => v1 => {
+  if (v1.tag === "Left") { return v1._1; }
+  return v;
+};
+const extendEither = {
+  extend: v => v1 => {
+    if (v1.tag === "Left") { return $Either("Left", v1._1); }
+    return $Either("Right", v(v1));
+  },
+  Functor0: () => functorEither
+};
+const eqEither = dictEq => dictEq1 => (
+  {
+    eq: x => y => {
+      if (x.tag === "Left") { return y.tag === "Left" && dictEq.eq(x._1)(y._1); }
+      return x.tag === "Right" && y.tag === "Right" && dictEq1.eq(x._1)(y._1);
+    }
+  }
+);
+const ordEither = dictOrd => {
+  const $0 = dictOrd.Eq0();
+  return dictOrd1 => {
+    const $1 = dictOrd1.Eq0();
+    const eqEither2 = {
+      eq: x => y => {
+        if (x.tag === "Left") { return y.tag === "Left" && $0.eq(x._1)(y._1); }
+        return x.tag === "Right" && y.tag === "Right" && $1.eq(x._1)(y._1);
+      }
+    };
+    return {
+      compare: x => y => {
+        if (x.tag === "Left") {
+          if (y.tag === "Left") { return dictOrd.compare(x._1)(y._1); }
+          return Data$dOrdering.LT;
+        }
+        if (y.tag === "Left") { return Data$dOrdering.GT; }
+        if (x.tag === "Right" && y.tag === "Right") { return dictOrd1.compare(x._1)(y._1); }
+        $runtime.fail();
+      },
+      Eq0: () => eqEither2
+    };
+  };
+};
+const eq1Either = dictEq => (
+  {
+    eq1: dictEq1 => x => y => {
+      if (x.tag === "Left") { return y.tag === "Left" && dictEq.eq(x._1)(y._1); }
+      return x.tag === "Right" && y.tag === "Right" && dictEq1.eq(x._1)(y._1);
+    }
+  }
+);
+const ord1Either = dictOrd => {
+  const ordEither1 = ordEither(dictOrd);
+  const $0 = dictOrd.Eq0();
+  const eq1Either1 = {
+    eq1: dictEq1 => x => y => {
+      if (x.tag === "Left") { return y.tag === "Left" && $0.eq(x._1)(y._1); }
+      return x.tag === "Right" && y.tag === "Right" && dictEq1.eq(x._1)(y._1);
+    }
+  };
+  return {compare1: dictOrd1 => ordEither1(dictOrd1).compare, Eq10: () => eq1Either1};
+};
+const either = v => v1 => v2 => {
+  if (v2.tag === "Left") { return v(v2._1); }
+  if (v2.tag === "Right") { return v1(v2._1); }
+  $runtime.fail();
+};
+const hush = v2 => {
+  if (v2.tag === "Left") { return Data$dMaybe.Nothing; }
+  if (v2.tag === "Right") { return Data$dMaybe.$Maybe("Just", v2._1); }
+  $runtime.fail();
+};
+const isLeft = v2 => {
+  if (v2.tag === "Left") { return true; }
+  if (v2.tag === "Right") { return false; }
+  $runtime.fail();
+};
+const isRight = v2 => {
+  if (v2.tag === "Left") { return false; }
+  if (v2.tag === "Right") { return true; }
+  $runtime.fail();
+};
+const choose = dictAlt => {
+  const $0 = dictAlt.Functor0();
+  return a => b => dictAlt.alt($0.map(Left)(a))($0.map(Right)(b));
+};
+const boundedEither = dictBounded => {
+  const bottom = dictBounded.bottom;
+  const ordEither1 = ordEither(dictBounded.Ord0());
+  return dictBounded1 => {
+    const ordEither2 = ordEither1(dictBounded1.Ord0());
+    return {top: $Either("Right", dictBounded1.top), bottom: $Either("Left", bottom), Ord0: () => ordEither2};
+  };
+};
+const blush = v2 => {
+  if (v2.tag === "Left") { return Data$dMaybe.$Maybe("Just", v2._1); }
+  if (v2.tag === "Right") { return Data$dMaybe.Nothing; }
+  $runtime.fail();
+};
+const applyEither = {
+  apply: v => v1 => {
+    if (v.tag === "Left") { return $Either("Left", v._1); }
+    if (v.tag === "Right") {
+      if (v1.tag === "Left") { return $Either("Left", v1._1); }
+      if (v1.tag === "Right") { return $Either("Right", v._1(v1._1)); }
+    }
+    $runtime.fail();
+  },
+  Functor0: () => functorEither
+};
+const bindEither = {
+  bind: v2 => {
+    if (v2.tag === "Left") {
+      const $0 = v2._1;
+      return v => $Either("Left", $0);
+    }
+    if (v2.tag === "Right") {
+      const $0 = v2._1;
+      return f => f($0);
+    }
+    $runtime.fail();
+  },
+  Apply0: () => applyEither
+};
+const semigroupEither = dictSemigroup => (
+  {
+    append: x => y => {
+      if (x.tag === "Left") { return $Either("Left", x._1); }
+      if (x.tag === "Right") {
+        if (y.tag === "Left") { return $Either("Left", y._1); }
+        if (y.tag === "Right") { return $Either("Right", dictSemigroup.append(x._1)(y._1)); }
+      }
+      $runtime.fail();
+    }
+  }
+);
+const applicativeEither = {pure: Right, Apply0: () => applyEither};
+const monadEither = {Applicative0: () => applicativeEither, Bind1: () => bindEither};
+const altEither = {
+  alt: v => v1 => {
+    if (v.tag === "Left") { return v1; }
+    return v;
+  },
+  Functor0: () => functorEither
+};
+export {
+  $Either,
+  Left,
+  Right,
+  altEither,
+  applicativeEither,
+  applyEither,
+  bindEither,
+  blush,
+  boundedEither,
+  choose,
+  either,
+  eq1Either,
+  eqEither,
+  extendEither,
+  fromLeft,
+  fromLeft$p,
+  fromRight,
+  fromRight$p,
+  functorEither,
+  genericEither,
+  hush,
+  invariantEither,
+  isLeft,
+  isRight,
+  monadEither,
+  note,
+  note$p,
+  ord1Either,
+  ordEither,
+  semigroupEither,
+  showEither
+};

package/output-es/Data.Either.Inject/index.js

@@ -0,0 +1,25 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+const prj = dict => dict.prj;
+const injectReflexive = {inj: x => x, prj: Data$dMaybe.Just};
+const injectLeft = {
+  inj: Data$dEither.Left,
+  prj: v2 => {
+    if (v2.tag === "Left") { return Data$dMaybe.$Maybe("Just", v2._1); }
+    if (v2.tag === "Right") { return Data$dMaybe.Nothing; }
+    $runtime.fail();
+  }
+};
+const inj = dict => dict.inj;
+const injectRight = dictInject => (
+  {
+    inj: x => Data$dEither.$Either("Right", dictInject.inj(x)),
+    prj: v2 => {
+      if (v2.tag === "Left") { return Data$dMaybe.Nothing; }
+      if (v2.tag === "Right") { return dictInject.prj(v2._1); }
+      $runtime.fail();
+    }
+  }
+);
+export {inj, injectLeft, injectReflexive, injectRight, prj};