@explorable-viz/fluid 0.12.3 → 0.12.5

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

@@ -0,0 +1,303 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dConst from "../Data.Const/index.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dFunctor$dApp from "../Data.Functor.App/index.js";
+import * as Data$dFunctor$dCompose from "../Data.Functor.Compose/index.js";
+import * as Data$dFunctor$dProduct from "../Data.Functor.Product/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dMaybe$dFirst from "../Data.Maybe.First/index.js";
+import * as Data$dMaybe$dLast from "../Data.Maybe.Last/index.js";
+import * as Data$dMonoid$dAdditive from "../Data.Monoid.Additive/index.js";
+import * as Data$dMonoid$dConj from "../Data.Monoid.Conj/index.js";
+import * as Data$dMonoid$dDisj from "../Data.Monoid.Disj/index.js";
+import * as Data$dMonoid$dDual from "../Data.Monoid.Dual/index.js";
+import * as Data$dMonoid$dMultiplicative from "../Data.Monoid.Multiplicative/index.js";
+import * as Data$dTraversable$dAccum$dInternal from "../Data.Traversable.Accum.Internal/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import {traverseArrayImpl} from "./foreign.js";
+const identity = x => x;
+const traverse = dict => dict.traverse;
+const traversableTuple = {
+  traverse: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dTuple.Tuple(v._1))(f(v._2)),
+  sequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dTuple.Tuple(v._1))(v._2),
+  Functor0: () => Data$dTuple.functorTuple,
+  Foldable1: () => Data$dFoldable.foldableTuple
+};
+const traversableMultiplicative = {
+  traverse: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dMultiplicative.Multiplicative)(f(v)),
+  sequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dMultiplicative.Multiplicative)(v),
+  Functor0: () => Data$dMonoid$dMultiplicative.functorMultiplicative,
+  Foldable1: () => Data$dFoldable.foldableMultiplicative
+};
+const traversableMaybe = {
+  traverse: dictApplicative => v => v1 => {
+    if (v1.tag === "Nothing") { return dictApplicative.pure(Data$dMaybe.Nothing); }
+    if (v1.tag === "Just") { return dictApplicative.Apply0().Functor0().map(Data$dMaybe.Just)(v(v1._1)); }
+    $runtime.fail();
+  },
+  sequence: dictApplicative => v => {
+    if (v.tag === "Nothing") { return dictApplicative.pure(Data$dMaybe.Nothing); }
+    if (v.tag === "Just") { return dictApplicative.Apply0().Functor0().map(Data$dMaybe.Just)(v._1); }
+    $runtime.fail();
+  },
+  Functor0: () => Data$dMaybe.functorMaybe,
+  Foldable1: () => Data$dFoldable.foldableMaybe
+};
+const traversableIdentity = {
+  traverse: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dIdentity.Identity)(f(v)),
+  sequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dIdentity.Identity)(v),
+  Functor0: () => Data$dIdentity.functorIdentity,
+  Foldable1: () => Data$dFoldable.foldableIdentity
+};
+const traversableEither = {
+  traverse: dictApplicative => v => v1 => {
+    if (v1.tag === "Left") { return dictApplicative.pure(Data$dEither.$Either("Left", v1._1)); }
+    if (v1.tag === "Right") { return dictApplicative.Apply0().Functor0().map(Data$dEither.Right)(v(v1._1)); }
+    $runtime.fail();
+  },
+  sequence: dictApplicative => v => {
+    if (v.tag === "Left") { return dictApplicative.pure(Data$dEither.$Either("Left", v._1)); }
+    if (v.tag === "Right") { return dictApplicative.Apply0().Functor0().map(Data$dEither.Right)(v._1); }
+    $runtime.fail();
+  },
+  Functor0: () => Data$dEither.functorEither,
+  Foldable1: () => Data$dFoldable.foldableEither
+};
+const traversableDual = {
+  traverse: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dDual.Dual)(f(v)),
+  sequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dDual.Dual)(v),
+  Functor0: () => Data$dMonoid$dDual.functorDual,
+  Foldable1: () => Data$dFoldable.foldableDual
+};
+const traversableDisj = {
+  traverse: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dDisj.Disj)(f(v)),
+  sequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dDisj.Disj)(v),
+  Functor0: () => Data$dMonoid$dDisj.functorDisj,
+  Foldable1: () => Data$dFoldable.foldableDisj
+};
+const traversableConst = {
+  traverse: dictApplicative => v => v1 => dictApplicative.pure(v1),
+  sequence: dictApplicative => v => dictApplicative.pure(v),
+  Functor0: () => Data$dConst.functorConst,
+  Foldable1: () => Data$dFoldable.foldableConst
+};
+const traversableConj = {
+  traverse: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dConj.Conj)(f(v)),
+  sequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dConj.Conj)(v),
+  Functor0: () => Data$dMonoid$dConj.functorConj,
+  Foldable1: () => Data$dFoldable.foldableConj
+};
+const traversableCompose = dictTraversable => {
+  const $0 = dictTraversable.Functor0();
+  const $1 = dictTraversable.Foldable1();
+  return dictTraversable1 => {
+    const $2 = dictTraversable1.Functor0();
+    const functorCompose1 = {map: f => v => $0.map($2.map(f))(v)};
+    const $3 = dictTraversable1.Foldable1();
+    const foldableCompose1 = {
+      foldr: f => i => v => $1.foldr((() => {
+        const $4 = $3.foldr(f);
+        return b => a => $4(a)(b);
+      })())(i)(v),
+      foldl: f => i => v => $1.foldl($3.foldl(f))(i)(v),
+      foldMap: dictMonoid => {
+        const foldMap4 = $1.foldMap(dictMonoid);
+        const foldMap5 = $3.foldMap(dictMonoid);
+        return f => v => foldMap4(foldMap5(f))(v);
+      }
+    };
+    return {
+      traverse: dictApplicative => {
+        const traverse4 = dictTraversable.traverse(dictApplicative);
+        const traverse5 = dictTraversable1.traverse(dictApplicative);
+        return f => v => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dCompose.Compose)(traverse4(traverse5(f))(v));
+      },
+      sequence: dictApplicative => traversableCompose(dictTraversable)(dictTraversable1).traverse(dictApplicative)(identity),
+      Functor0: () => functorCompose1,
+      Foldable1: () => foldableCompose1
+    };
+  };
+};
+const traversableAdditive = {
+  traverse: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dAdditive.Additive)(f(v)),
+  sequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dMonoid$dAdditive.Additive)(v),
+  Functor0: () => Data$dMonoid$dAdditive.functorAdditive,
+  Foldable1: () => Data$dFoldable.foldableAdditive
+};
+const sequenceDefault = dictTraversable => dictApplicative => dictTraversable.traverse(dictApplicative)(identity);
+const traversableArray = {
+  traverse: dictApplicative => {
+    const Apply0 = dictApplicative.Apply0();
+    return traverseArrayImpl(Apply0.apply)(Apply0.Functor0().map)(dictApplicative.pure);
+  },
+  sequence: dictApplicative => traversableArray.traverse(dictApplicative)(identity),
+  Functor0: () => Data$dFunctor.functorArray,
+  Foldable1: () => Data$dFoldable.foldableArray
+};
+const sequence = dict => dict.sequence;
+const traversableApp = dictTraversable => {
+  const $0 = dictTraversable.Functor0();
+  const $1 = dictTraversable.Foldable1();
+  const foldableApp = {foldr: f => i => v => $1.foldr(f)(i)(v), foldl: f => i => v => $1.foldl(f)(i)(v), foldMap: dictMonoid => $1.foldMap(dictMonoid)};
+  return {
+    traverse: dictApplicative => {
+      const traverse3 = dictTraversable.traverse(dictApplicative);
+      return f => v => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dApp.App)(traverse3(f)(v));
+    },
+    sequence: dictApplicative => {
+      const sequence3 = dictTraversable.sequence(dictApplicative);
+      return v => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dApp.App)(sequence3(v));
+    },
+    Functor0: () => $0,
+    Foldable1: () => foldableApp
+  };
+};
+const traversableCoproduct = dictTraversable => {
+  const $0 = dictTraversable.Functor0();
+  const foldableCoproduct = Data$dFoldable.foldableCoproduct(dictTraversable.Foldable1());
+  return dictTraversable1 => {
+    const $1 = dictTraversable1.Functor0();
+    const functorCoproduct1 = {
+      map: f => v => {
+        const $2 = $0.map(f);
+        const $3 = $1.map(f);
+        if (v.tag === "Left") { return Data$dEither.$Either("Left", $2(v._1)); }
+        if (v.tag === "Right") { return Data$dEither.$Either("Right", $3(v._1)); }
+        $runtime.fail();
+      }
+    };
+    const foldableCoproduct1 = foldableCoproduct(dictTraversable1.Foldable1());
+    return {
+      traverse: dictApplicative => {
+        const $2 = dictApplicative.Apply0().Functor0();
+        const traverse4 = dictTraversable.traverse(dictApplicative);
+        const traverse5 = dictTraversable1.traverse(dictApplicative);
+        return f => {
+          const $3 = $2.map(x => Data$dEither.$Either("Left", x));
+          const $4 = traverse4(f);
+          const $5 = $2.map(x => Data$dEither.$Either("Right", x));
+          const $6 = traverse5(f);
+          return v2 => {
+            if (v2.tag === "Left") { return $3($4(v2._1)); }
+            if (v2.tag === "Right") { return $5($6(v2._1)); }
+            $runtime.fail();
+          };
+        };
+      },
+      sequence: dictApplicative => {
+        const $2 = dictApplicative.Apply0().Functor0();
+        const $3 = $2.map(x => Data$dEither.$Either("Left", x));
+        const $4 = dictTraversable.sequence(dictApplicative);
+        const $5 = $2.map(x => Data$dEither.$Either("Right", x));
+        const $6 = dictTraversable1.sequence(dictApplicative);
+        return v2 => {
+          if (v2.tag === "Left") { return $3($4(v2._1)); }
+          if (v2.tag === "Right") { return $5($6(v2._1)); }
+          $runtime.fail();
+        };
+      },
+      Functor0: () => functorCoproduct1,
+      Foldable1: () => foldableCoproduct1
+    };
+  };
+};
+const traversableFirst = {
+  traverse: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dMaybe$dFirst.First)(traversableMaybe.traverse(dictApplicative)(f)(v)),
+  sequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dMaybe$dFirst.First)(traversableMaybe.sequence(dictApplicative)(v)),
+  Functor0: () => Data$dMaybe.functorMaybe,
+  Foldable1: () => Data$dFoldable.foldableFirst
+};
+const traversableLast = {
+  traverse: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dMaybe$dLast.Last)(traversableMaybe.traverse(dictApplicative)(f)(v)),
+  sequence: dictApplicative => v => dictApplicative.Apply0().Functor0().map(Data$dMaybe$dLast.Last)(traversableMaybe.sequence(dictApplicative)(v)),
+  Functor0: () => Data$dMaybe.functorMaybe,
+  Foldable1: () => Data$dFoldable.foldableLast
+};
+const traversableProduct = dictTraversable => {
+  const $0 = dictTraversable.Functor0();
+  const foldableProduct = Data$dFoldable.foldableProduct(dictTraversable.Foldable1());
+  return dictTraversable1 => {
+    const $1 = dictTraversable1.Functor0();
+    const functorProduct1 = {map: f => v => Data$dTuple.$Tuple($0.map(f)(v._1), $1.map(f)(v._2))};
+    const foldableProduct1 = foldableProduct(dictTraversable1.Foldable1());
+    return {
+      traverse: dictApplicative => {
+        const $2 = dictApplicative.Apply0();
+        const traverse4 = dictTraversable.traverse(dictApplicative);
+        const traverse5 = dictTraversable1.traverse(dictApplicative);
+        return f => v => $2.apply($2.Functor0().map(Data$dFunctor$dProduct.product)(traverse4(f)(v._1)))(traverse5(f)(v._2));
+      },
+      sequence: dictApplicative => {
+        const $2 = dictApplicative.Apply0();
+        const sequence4 = dictTraversable.sequence(dictApplicative);
+        const sequence5 = dictTraversable1.sequence(dictApplicative);
+        return v => $2.apply($2.Functor0().map(Data$dFunctor$dProduct.product)(sequence4(v._1)))(sequence5(v._2));
+      },
+      Functor0: () => functorProduct1,
+      Foldable1: () => foldableProduct1
+    };
+  };
+};
+const traverseDefault = dictTraversable => dictApplicative => {
+  const sequence3 = dictTraversable.sequence(dictApplicative);
+  return f => ta => sequence3(dictTraversable.Functor0().map(f)(ta));
+};
+const mapAccumR = dictTraversable => {
+  const traverse2 = dictTraversable.traverse(Data$dTraversable$dAccum$dInternal.applicativeStateR);
+  return f => s0 => xs => traverse2(a => s => f(s)(a))(xs)(s0);
+};
+const scanr = dictTraversable => {
+  const mapAccumR1 = mapAccumR(dictTraversable);
+  return f => b0 => xs => mapAccumR1(b => a => {
+    const b$p = f(a)(b);
+    return {accum: b$p, value: b$p};
+  })(b0)(xs).value;
+};
+const mapAccumL = dictTraversable => {
+  const traverse2 = dictTraversable.traverse(Data$dTraversable$dAccum$dInternal.applicativeStateL);
+  return f => s0 => xs => traverse2(a => s => f(s)(a))(xs)(s0);
+};
+const scanl = dictTraversable => {
+  const mapAccumL1 = mapAccumL(dictTraversable);
+  return f => b0 => xs => mapAccumL1(b => a => {
+    const b$p = f(b)(a);
+    return {accum: b$p, value: b$p};
+  })(b0)(xs).value;
+};
+const $$for = dictApplicative => dictTraversable => {
+  const traverse2 = dictTraversable.traverse(dictApplicative);
+  return x => f => traverse2(f)(x);
+};
+export {
+  $$for as for,
+  identity,
+  mapAccumL,
+  mapAccumR,
+  scanl,
+  scanr,
+  sequence,
+  sequenceDefault,
+  traversableAdditive,
+  traversableApp,
+  traversableArray,
+  traversableCompose,
+  traversableConj,
+  traversableConst,
+  traversableCoproduct,
+  traversableDisj,
+  traversableDual,
+  traversableEither,
+  traversableFirst,
+  traversableIdentity,
+  traversableLast,
+  traversableMaybe,
+  traversableMultiplicative,
+  traversableProduct,
+  traversableTuple,
+  traverse,
+  traverseDefault
+};
+export * from "./foreign.js";

package/output-es/Data.Traversable.Accum/index.js

@@ -0,0 +1 @@
+export {};

package/output-es/Data.Traversable.Accum.Internal/index.js

@@ -0,0 +1,35 @@
+const StateR = x => x;
+const StateL = x => x;
+const stateR = v => v;
+const stateL = v => v;
+const functorStateR = {
+  map: f => k => s => {
+    const v = k(s);
+    return {accum: v.accum, value: f(v.value)};
+  }
+};
+const functorStateL = {
+  map: f => k => s => {
+    const v = k(s);
+    return {accum: v.accum, value: f(v.value)};
+  }
+};
+const applyStateR = {
+  apply: f => x => s => {
+    const v = x(s);
+    const v1 = f(v.accum);
+    return {accum: v1.accum, value: v1.value(v.value)};
+  },
+  Functor0: () => functorStateR
+};
+const applyStateL = {
+  apply: f => x => s => {
+    const v = f(s);
+    const v1 = x(v.accum);
+    return {accum: v1.accum, value: v.value(v1.value)};
+  },
+  Functor0: () => functorStateL
+};
+const applicativeStateR = {pure: a => s => ({accum: s, value: a}), Apply0: () => applyStateR};
+const applicativeStateL = {pure: a => s => ({accum: s, value: a}), Apply0: () => applyStateL};
+export {StateL, StateR, applicativeStateL, applicativeStateR, applyStateL, applyStateR, functorStateL, functorStateR, stateL, stateR};

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

@@ -0,0 +1,280 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dEither from "../Data.Either/index.js";
+import * as Data$dFoldableWithIndex from "../Data.FoldableWithIndex/index.js";
+import * as Data$dFunctor$dApp from "../Data.Functor.App/index.js";
+import * as Data$dFunctor$dCompose from "../Data.Functor.Compose/index.js";
+import * as Data$dFunctor$dProduct from "../Data.Functor.Product/index.js";
+import * as Data$dFunctorWithIndex from "../Data.FunctorWithIndex/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Data$dTraversable from "../Data.Traversable/index.js";
+import * as Data$dTraversable$dAccum$dInternal from "../Data.Traversable.Accum.Internal/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+const traverseWithIndexDefault = dictTraversableWithIndex => dictApplicative => {
+  const sequence1 = dictTraversableWithIndex.Traversable2().sequence(dictApplicative);
+  return f => {
+    const $0 = dictTraversableWithIndex.FunctorWithIndex0().mapWithIndex(f);
+    return x => sequence1($0(x));
+  };
+};
+const traverseWithIndex = dict => dict.traverseWithIndex;
+const traverseDefault = dictTraversableWithIndex => dictApplicative => {
+  const traverseWithIndex2 = dictTraversableWithIndex.traverseWithIndex(dictApplicative);
+  return f => traverseWithIndex2(v => f);
+};
+const traversableWithIndexTuple = {
+  traverseWithIndex: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dTuple.Tuple(v._1))(f()(v._2)),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexTuple,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexTuple,
+  Traversable2: () => Data$dTraversable.traversableTuple
+};
+const traversableWithIndexProduct = dictTraversableWithIndex => {
+  const $0 = dictTraversableWithIndex.FunctorWithIndex0();
+  const $1 = $0.Functor0();
+  const foldableWithIndexProduct = Data$dFoldableWithIndex.foldableWithIndexProduct(dictTraversableWithIndex.FoldableWithIndex1());
+  const traversableProduct = Data$dTraversable.traversableProduct(dictTraversableWithIndex.Traversable2());
+  return dictTraversableWithIndex1 => {
+    const $2 = dictTraversableWithIndex1.FunctorWithIndex0();
+    const $3 = $2.Functor0();
+    const functorWithIndexProduct1 = (() => {
+      const functorProduct1 = {map: f => v => Data$dTuple.$Tuple($1.map(f)(v._1), $3.map(f)(v._2))};
+      return {
+        mapWithIndex: f => v => Data$dTuple.$Tuple($0.mapWithIndex(x => f(Data$dEither.$Either("Left", x)))(v._1), $2.mapWithIndex(x => f(Data$dEither.$Either("Right", x)))(v._2)),
+        Functor0: () => functorProduct1
+      };
+    })();
+    const foldableWithIndexProduct1 = foldableWithIndexProduct(dictTraversableWithIndex1.FoldableWithIndex1());
+    const traversableProduct1 = traversableProduct(dictTraversableWithIndex1.Traversable2());
+    return {
+      traverseWithIndex: dictApplicative => {
+        const $4 = dictApplicative.Apply0();
+        const traverseWithIndex3 = dictTraversableWithIndex.traverseWithIndex(dictApplicative);
+        const traverseWithIndex4 = dictTraversableWithIndex1.traverseWithIndex(dictApplicative);
+        return f => v => $4.apply($4.Functor0().map(Data$dFunctor$dProduct.product)(traverseWithIndex3(x => f(Data$dEither.$Either("Left", x)))(v._1)))(traverseWithIndex4(x => f(Data$dEither.$Either(
+          "Right",
+          x
+        )))(v._2));
+      },
+      FunctorWithIndex0: () => functorWithIndexProduct1,
+      FoldableWithIndex1: () => foldableWithIndexProduct1,
+      Traversable2: () => traversableProduct1
+    };
+  };
+};
+const traversableWithIndexMultiplicative = {
+  traverseWithIndex: dictApplicative => f => Data$dTraversable.traversableMultiplicative.traverse(dictApplicative)(f()),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexMultiplicative,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexMultiplicative,
+  Traversable2: () => Data$dTraversable.traversableMultiplicative
+};
+const traversableWithIndexMaybe = {
+  traverseWithIndex: dictApplicative => f => Data$dTraversable.traversableMaybe.traverse(dictApplicative)(f()),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexMaybe,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexMaybe,
+  Traversable2: () => Data$dTraversable.traversableMaybe
+};
+const traversableWithIndexLast = {
+  traverseWithIndex: dictApplicative => f => Data$dTraversable.traversableLast.traverse(dictApplicative)(f()),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexLast,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexLast,
+  Traversable2: () => Data$dTraversable.traversableLast
+};
+const traversableWithIndexIdentity = {
+  traverseWithIndex: dictApplicative => f => v => dictApplicative.Apply0().Functor0().map(Data$dIdentity.Identity)(f()(v)),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexIdentity,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexIdentity,
+  Traversable2: () => Data$dTraversable.traversableIdentity
+};
+const traversableWithIndexFirst = {
+  traverseWithIndex: dictApplicative => f => Data$dTraversable.traversableFirst.traverse(dictApplicative)(f()),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexFirst,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexFirst,
+  Traversable2: () => Data$dTraversable.traversableFirst
+};
+const traversableWithIndexEither = {
+  traverseWithIndex: dictApplicative => v => v1 => {
+    if (v1.tag === "Left") { return dictApplicative.pure(Data$dEither.$Either("Left", v1._1)); }
+    if (v1.tag === "Right") { return dictApplicative.Apply0().Functor0().map(Data$dEither.Right)(v()(v1._1)); }
+    $runtime.fail();
+  },
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexEither,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexEither,
+  Traversable2: () => Data$dTraversable.traversableEither
+};
+const traversableWithIndexDual = {
+  traverseWithIndex: dictApplicative => f => Data$dTraversable.traversableDual.traverse(dictApplicative)(f()),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexDual,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexDual,
+  Traversable2: () => Data$dTraversable.traversableDual
+};
+const traversableWithIndexDisj = {
+  traverseWithIndex: dictApplicative => f => Data$dTraversable.traversableDisj.traverse(dictApplicative)(f()),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexDisj,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexDisj,
+  Traversable2: () => Data$dTraversable.traversableDisj
+};
+const traversableWithIndexCoproduct = dictTraversableWithIndex => {
+  const functorWithIndexCoproduct = Data$dFunctorWithIndex.functorWithIndexCoproduct(dictTraversableWithIndex.FunctorWithIndex0());
+  const foldableWithIndexCoproduct = Data$dFoldableWithIndex.foldableWithIndexCoproduct(dictTraversableWithIndex.FoldableWithIndex1());
+  const traversableCoproduct = Data$dTraversable.traversableCoproduct(dictTraversableWithIndex.Traversable2());
+  return dictTraversableWithIndex1 => {
+    const functorWithIndexCoproduct1 = functorWithIndexCoproduct(dictTraversableWithIndex1.FunctorWithIndex0());
+    const foldableWithIndexCoproduct1 = foldableWithIndexCoproduct(dictTraversableWithIndex1.FoldableWithIndex1());
+    const traversableCoproduct1 = traversableCoproduct(dictTraversableWithIndex1.Traversable2());
+    return {
+      traverseWithIndex: dictApplicative => {
+        const $0 = dictApplicative.Apply0().Functor0();
+        const traverseWithIndex3 = dictTraversableWithIndex.traverseWithIndex(dictApplicative);
+        const traverseWithIndex4 = dictTraversableWithIndex1.traverseWithIndex(dictApplicative);
+        return f => {
+          const $1 = $0.map(x => Data$dEither.$Either("Left", x));
+          const $2 = traverseWithIndex3(x => f(Data$dEither.$Either("Left", x)));
+          const $3 = $0.map(x => Data$dEither.$Either("Right", x));
+          const $4 = traverseWithIndex4(x => f(Data$dEither.$Either("Right", x)));
+          return v2 => {
+            if (v2.tag === "Left") { return $1($2(v2._1)); }
+            if (v2.tag === "Right") { return $3($4(v2._1)); }
+            $runtime.fail();
+          };
+        };
+      },
+      FunctorWithIndex0: () => functorWithIndexCoproduct1,
+      FoldableWithIndex1: () => foldableWithIndexCoproduct1,
+      Traversable2: () => traversableCoproduct1
+    };
+  };
+};
+const traversableWithIndexConst = {
+  traverseWithIndex: dictApplicative => v => v1 => dictApplicative.pure(v1),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexConst,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexConst,
+  Traversable2: () => Data$dTraversable.traversableConst
+};
+const traversableWithIndexConj = {
+  traverseWithIndex: dictApplicative => f => Data$dTraversable.traversableConj.traverse(dictApplicative)(f()),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexConj,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexConj,
+  Traversable2: () => Data$dTraversable.traversableConj
+};
+const traversableWithIndexCompose = dictTraversableWithIndex => {
+  const $0 = dictTraversableWithIndex.FunctorWithIndex0();
+  const $1 = $0.Functor0();
+  const foldableWithIndexCompose = Data$dFoldableWithIndex.foldableWithIndexCompose(dictTraversableWithIndex.FoldableWithIndex1());
+  const traversableCompose = Data$dTraversable.traversableCompose(dictTraversableWithIndex.Traversable2());
+  return dictTraversableWithIndex1 => {
+    const $2 = dictTraversableWithIndex1.FunctorWithIndex0();
+    const $3 = $2.Functor0();
+    const functorWithIndexCompose1 = (() => {
+      const functorCompose1 = {map: f => v => $1.map($3.map(f))(v)};
+      return {mapWithIndex: f => v => $0.mapWithIndex(x => $2.mapWithIndex(b => f(Data$dTuple.$Tuple(x, b))))(v), Functor0: () => functorCompose1};
+    })();
+    const foldableWithIndexCompose1 = foldableWithIndexCompose(dictTraversableWithIndex1.FoldableWithIndex1());
+    const traversableCompose1 = traversableCompose(dictTraversableWithIndex1.Traversable2());
+    return {
+      traverseWithIndex: dictApplicative => {
+        const traverseWithIndex3 = dictTraversableWithIndex.traverseWithIndex(dictApplicative);
+        const traverseWithIndex4 = dictTraversableWithIndex1.traverseWithIndex(dictApplicative);
+        return f => v => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dCompose.Compose)(traverseWithIndex3(x => traverseWithIndex4(b => f(Data$dTuple.$Tuple(x, b))))(v));
+      },
+      FunctorWithIndex0: () => functorWithIndexCompose1,
+      FoldableWithIndex1: () => foldableWithIndexCompose1,
+      Traversable2: () => traversableCompose1
+    };
+  };
+};
+const traversableWithIndexArray = {
+  traverseWithIndex: dictApplicative => {
+    const sequence1 = traversableWithIndexArray.Traversable2().sequence(dictApplicative);
+    return f => {
+      const $0 = traversableWithIndexArray.FunctorWithIndex0().mapWithIndex(f);
+      return x => sequence1($0(x));
+    };
+  },
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexArray,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexArray,
+  Traversable2: () => Data$dTraversable.traversableArray
+};
+const traversableWithIndexApp = dictTraversableWithIndex => {
+  const $0 = dictTraversableWithIndex.FunctorWithIndex0();
+  const $1 = $0.Functor0();
+  const functorWithIndexApp = {mapWithIndex: f => v => $0.mapWithIndex(f)(v), Functor0: () => $1};
+  const $2 = dictTraversableWithIndex.FoldableWithIndex1();
+  const $3 = $2.Foldable0();
+  const foldableWithIndexApp = (() => {
+    const foldableApp = {foldr: f => i => v => $3.foldr(f)(i)(v), foldl: f => i => v => $3.foldl(f)(i)(v), foldMap: dictMonoid => $3.foldMap(dictMonoid)};
+    return {
+      foldrWithIndex: f => z => v => $2.foldrWithIndex(f)(z)(v),
+      foldlWithIndex: f => z => v => $2.foldlWithIndex(f)(z)(v),
+      foldMapWithIndex: dictMonoid => $2.foldMapWithIndex(dictMonoid),
+      Foldable0: () => foldableApp
+    };
+  })();
+  const traversableApp = Data$dTraversable.traversableApp(dictTraversableWithIndex.Traversable2());
+  return {
+    traverseWithIndex: dictApplicative => {
+      const traverseWithIndex2 = dictTraversableWithIndex.traverseWithIndex(dictApplicative);
+      return f => v => dictApplicative.Apply0().Functor0().map(Data$dFunctor$dApp.App)(traverseWithIndex2(f)(v));
+    },
+    FunctorWithIndex0: () => functorWithIndexApp,
+    FoldableWithIndex1: () => foldableWithIndexApp,
+    Traversable2: () => traversableApp
+  };
+};
+const traversableWithIndexAdditive = {
+  traverseWithIndex: dictApplicative => f => Data$dTraversable.traversableAdditive.traverse(dictApplicative)(f()),
+  FunctorWithIndex0: () => Data$dFunctorWithIndex.functorWithIndexAdditive,
+  FoldableWithIndex1: () => Data$dFoldableWithIndex.foldableWithIndexAdditive,
+  Traversable2: () => Data$dTraversable.traversableAdditive
+};
+const mapAccumRWithIndex = dictTraversableWithIndex => {
+  const traverseWithIndex1 = dictTraversableWithIndex.traverseWithIndex(Data$dTraversable$dAccum$dInternal.applicativeStateR);
+  return f => s0 => xs => traverseWithIndex1(i => a => s => f(i)(s)(a))(xs)(s0);
+};
+const scanrWithIndex = dictTraversableWithIndex => {
+  const mapAccumRWithIndex1 = mapAccumRWithIndex(dictTraversableWithIndex);
+  return f => b0 => xs => mapAccumRWithIndex1(i => b => a => {
+    const b$p = f(i)(a)(b);
+    return {accum: b$p, value: b$p};
+  })(b0)(xs).value;
+};
+const mapAccumLWithIndex = dictTraversableWithIndex => {
+  const traverseWithIndex1 = dictTraversableWithIndex.traverseWithIndex(Data$dTraversable$dAccum$dInternal.applicativeStateL);
+  return f => s0 => xs => traverseWithIndex1(i => a => s => f(i)(s)(a))(xs)(s0);
+};
+const scanlWithIndex = dictTraversableWithIndex => {
+  const mapAccumLWithIndex1 = mapAccumLWithIndex(dictTraversableWithIndex);
+  return f => b0 => xs => mapAccumLWithIndex1(i => b => a => {
+    const b$p = f(i)(b)(a);
+    return {accum: b$p, value: b$p};
+  })(b0)(xs).value;
+};
+const forWithIndex = dictApplicative => dictTraversableWithIndex => {
+  const $0 = dictTraversableWithIndex.traverseWithIndex(dictApplicative);
+  return b => a => $0(a)(b);
+};
+export {
+  forWithIndex,
+  mapAccumLWithIndex,
+  mapAccumRWithIndex,
+  scanlWithIndex,
+  scanrWithIndex,
+  traversableWithIndexAdditive,
+  traversableWithIndexApp,
+  traversableWithIndexArray,
+  traversableWithIndexCompose,
+  traversableWithIndexConj,
+  traversableWithIndexConst,
+  traversableWithIndexCoproduct,
+  traversableWithIndexDisj,
+  traversableWithIndexDual,
+  traversableWithIndexEither,
+  traversableWithIndexFirst,
+  traversableWithIndexIdentity,
+  traversableWithIndexLast,
+  traversableWithIndexMaybe,
+  traversableWithIndexMultiplicative,
+  traversableWithIndexProduct,
+  traversableWithIndexTuple,
+  traverseDefault,
+  traverseWithIndex,
+  traverseWithIndexDefault
+};