@explorable-viz/fluid 0.12.2 → 0.12.4

package/output-es/DataType/index.js

@@ -0,0 +1,276 @@
+import * as $runtime from "../runtime.js";
+import * as Data$dCodePoint$dUnicode$dInternal from "../Data.CodePoint.Unicode.Internal/index.js";
+import * as Data$dEnum from "../Data.Enum/index.js";
+import * as Data$dEq from "../Data.Eq/index.js";
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFunctor from "../Data.Functor/index.js";
+import * as Data$dList from "../Data.List/index.js";
+import * as Data$dList$dTypes from "../Data.List.Types/index.js";
+import * as Data$dMap$dInternal from "../Data.Map.Internal/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrd from "../Data.Ord/index.js";
+import * as Data$dSet from "../Data.Set/index.js";
+import * as Data$dShow from "../Data.Show/index.js";
+import * as Data$dString$dCodeUnits from "../Data.String.CodeUnits/index.js";
+import * as Data$dTuple from "../Data.Tuple/index.js";
+import * as Effect$dException from "../Effect.Exception/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+import * as Util from "../Util/index.js";
+import * as Util$dMap from "../Util.Map/index.js";
+const $DataType = (_1, _2) => ({tag: "DataType", _1, _2});
+const fromFoldable = /* #__PURE__ */ Foreign$dObject.fromFoldable(Data$dFoldable.foldableArray);
+const fromFoldable1 = /* #__PURE__ */ (() => {
+  const go = go$a0$copy => go$a1$copy => {
+    let go$a0 = go$a0$copy, go$a1 = go$a1$copy, go$c = true, go$r;
+    while (go$c) {
+      const b = go$a0, v = go$a1;
+      if (v.tag === "Nil") {
+        go$c = false;
+        go$r = b;
+        continue;
+      }
+      if (v.tag === "Cons") {
+        go$a0 = Data$dMap$dInternal.insert(Data$dOrd.ordString)(v._1)()(b);
+        go$a1 = v._2;
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$r;
+  };
+  const $0 = go(Data$dMap$dInternal.Leaf);
+  return x => $0((() => {
+    const go$1 = (m$p, z$p) => {
+      if (m$p.tag === "Leaf") { return z$p; }
+      if (m$p.tag === "Node") { return go$1(m$p._5, Data$dList$dTypes.$List("Cons", m$p._3, go$1(m$p._6, z$p))); }
+      $runtime.fail();
+    };
+    return go$1(x, Data$dList$dTypes.Nil);
+  })());
+})();
+const toUnfoldable = x => {
+  const go = (m$p, z$p) => {
+    if (m$p.tag === "Leaf") { return z$p; }
+    if (m$p.tag === "Node") { return go(m$p._5, Data$dList$dTypes.$List("Cons", m$p._3, go(m$p._6, z$p))); }
+    $runtime.fail();
+  };
+  const go$1 = go$1$a0$copy => go$1$a1$copy => {
+    let go$1$a0 = go$1$a0$copy, go$1$a1 = go$1$a1$copy, go$1$c = true, go$1$r;
+    while (go$1$c) {
+      const source = go$1$a0, memo = go$1$a1;
+      if (source.tag === "Nil") {
+        const go$2 = go$2$a0$copy => go$2$a1$copy => {
+          let go$2$a0 = go$2$a0$copy, go$2$a1 = go$2$a1$copy, go$2$c = true, go$2$r;
+          while (go$2$c) {
+            const b = go$2$a0, v = go$2$a1;
+            if (v.tag === "Nil") {
+              go$2$c = false;
+              go$2$r = b;
+              continue;
+            }
+            if (v.tag === "Cons") {
+              go$2$a0 = Data$dList$dTypes.$List("Cons", v._1, b);
+              go$2$a1 = v._2;
+              continue;
+            }
+            $runtime.fail();
+          }
+          return go$2$r;
+        };
+        go$1$c = false;
+        go$1$r = go$2(Data$dList$dTypes.Nil)(memo);
+        continue;
+      }
+      if (source.tag === "Cons") {
+        go$1$a0 = source._2;
+        go$1$a1 = Data$dList$dTypes.$List("Cons", source._1, memo);
+        continue;
+      }
+      $runtime.fail();
+    }
+    return go$1$r;
+  };
+  return go$1(go(x, Data$dList$dTypes.Nil))(Data$dList$dTypes.Nil);
+};
+const show = /* #__PURE__ */ (() => Data$dSet.showSet(Data$dShow.showString).show)();
+const DataType = value0 => value1 => $DataType(value0, value1);
+const typeName = v => v._1;
+const eqDataType = {eq: x => y => x._1 === y._1};
+const showDataType = {show: typeName};
+const isCtrOp = str => ":" === Util.definitely("absurd")(Data$dString$dCodeUnits.charAt(0)(str));
+const isCtrName = str => Data$dCodePoint$dUnicode$dInternal.checkAttr([512, 524288])(Data$dEnum.toCharCode(Util.definitely("absurd")(Data$dString$dCodeUnits.charAt(0)(str))));
+const showCtr = c => {
+  if (isCtrName(c)) { return c; }
+  if (":" === Util.definitely("absurd")(Data$dString$dCodeUnits.charAt(0)(c))) { return "(" + c + ")"; }
+  return Effect$dException.throwException(Effect$dException.error("absurd"))();
+};
+const f_z = "z";
+const f_y = "y";
+const f_x = "x";
+const f_width = "width";
+const f_tickLabels = "tickLabels";
+const f_stackedBars = "stackedBars";
+const f_size = "size";
+const f_segments = "segments";
+const f_points = "points";
+const f_plots = "plots";
+const f_name = "name";
+const f_legend = "legend";
+const f_labels = "labels";
+const f_height = "height";
+const f_colour = "c";
+const f_caption = "caption";
+const dataTypeFor = dict => dict.dataTypeFor;
+const dataType = name => {
+  const $0 = Data$dFunctor.arrayMap(v => Data$dTuple.$Tuple(v._1, v._2));
+  const $1 = DataType(name);
+  return x => $1(fromFoldable($0(x)));
+};
+const ctrs = v => fromFoldable1(Util$dMap.mapObjectString.keys(v._2));
+const cTrue = "True";
+const cText = "Text";
+const cSome = "Some";
+const cScatterPlot = "ScatterPlot";
+const cRotated = "Rotated";
+const cParagraph = "Paragraph";
+const cPair = "Pair";
+const cNone = "None";
+const cNil = "Nil";
+const cMultiView = "MultiView";
+const cLink = "Link";
+const cLinePlot = "LinePlot";
+const cLineChart = "LineChart";
+const cFalse = "False";
+const cDefault = "Default";
+const cCons = ":";
+const cBarChart = "BarChart";
+const dataTypes = /* #__PURE__ */ Data$dFoldable.foldrArray(Data$dList$dTypes.Cons)(Data$dList$dTypes.Nil)([
+  /* #__PURE__ */ dataType("Bool")([/* #__PURE__ */ Data$dTuple.$Tuple("True", 0), /* #__PURE__ */ Data$dTuple.$Tuple("False", 0)]),
+  /* #__PURE__ */ dataType("InfNum")([/* #__PURE__ */ Data$dTuple.$Tuple("FNum", 1), /* #__PURE__ */ Data$dTuple.$Tuple("Infty", 0)]),
+  /* #__PURE__ */ dataType("List")([/* #__PURE__ */ Data$dTuple.$Tuple("Nil", 0), /* #__PURE__ */ Data$dTuple.$Tuple(":", 2)]),
+  /* #__PURE__ */ dataType("Option")([/* #__PURE__ */ Data$dTuple.$Tuple("None", 0), /* #__PURE__ */ Data$dTuple.$Tuple("Some", 1)]),
+  /* #__PURE__ */ dataType("Ordering")([/* #__PURE__ */ Data$dTuple.$Tuple("GT", 0), /* #__PURE__ */ Data$dTuple.$Tuple("LT", 0), /* #__PURE__ */ Data$dTuple.$Tuple("EQ", 0)]),
+  /* #__PURE__ */ dataType("Pair")([/* #__PURE__ */ Data$dTuple.$Tuple("Pair", 2)]),
+  /* #__PURE__ */ dataType("Tree")([/* #__PURE__ */ Data$dTuple.$Tuple("Empty", 0), /* #__PURE__ */ Data$dTuple.$Tuple("NonEmpty", 3)]),
+  /* #__PURE__ */ dataType("LinePlot")([/* #__PURE__ */ Data$dTuple.$Tuple("LinePlot", 1)]),
+  /* #__PURE__ */ dataType("Orientation")([/* #__PURE__ */ Data$dTuple.$Tuple("Default", 0), /* #__PURE__ */ Data$dTuple.$Tuple("Rotated", 0)]),
+  /* #__PURE__ */ dataType("View")([
+    /* #__PURE__ */ Data$dTuple.$Tuple("BarChart", 1),
+    /* #__PURE__ */ Data$dTuple.$Tuple("LineChart", 1),
+    /* #__PURE__ */ Data$dTuple.$Tuple("MultiView", 1),
+    /* #__PURE__ */ Data$dTuple.$Tuple("Paragraph", 1),
+    /* #__PURE__ */ Data$dTuple.$Tuple("ScatterPlot", 1)
+  ]),
+  /* #__PURE__ */ dataType("Point")([/* #__PURE__ */ Data$dTuple.$Tuple("Point", 2)]),
+  /* #__PURE__ */ dataType("Orient")([/* #__PURE__ */ Data$dTuple.$Tuple("Horiz", 0), /* #__PURE__ */ Data$dTuple.$Tuple("Vert", 0)]),
+  /* #__PURE__ */ dataType("GraphicsElement")([
+    /* #__PURE__ */ Data$dTuple.$Tuple("Circle", 4),
+    /* #__PURE__ */ Data$dTuple.$Tuple("Group", 1),
+    /* #__PURE__ */ Data$dTuple.$Tuple("Line", 4),
+    /* #__PURE__ */ Data$dTuple.$Tuple("Polyline", 3),
+    /* #__PURE__ */ Data$dTuple.$Tuple("Polymarkers", 2),
+    /* #__PURE__ */ Data$dTuple.$Tuple("Rect", 5),
+    /* #__PURE__ */ Data$dTuple.$Tuple("String", 5),
+    /* #__PURE__ */ Data$dTuple.$Tuple("Viewport", 9)
+  ]),
+  /* #__PURE__ */ dataType("Transform")([/* #__PURE__ */ Data$dTuple.$Tuple("Scale", 2), /* #__PURE__ */ Data$dTuple.$Tuple("Translate", 2)]),
+  /* #__PURE__ */ dataType("Marker")([/* #__PURE__ */ Data$dTuple.$Tuple("Arrowhead", 0)]),
+  /* #__PURE__ */ dataType("ParaFragment")([/* #__PURE__ */ Data$dTuple.$Tuple("Text", 1), /* #__PURE__ */ Data$dTuple.$Tuple("Link", 2)])
+]);
+const ctrToDataType = /* #__PURE__ */ (() => Foreign$dObject.fromFoldable(Data$dList$dTypes.foldableList)(Data$dList$dTypes.bindList.bind(Data$dList$dTypes.listMap(d => Data$dList$dTypes.listMap(v => Data$dTuple.$Tuple(
+  v,
+  d
+))(toUnfoldable(fromFoldable1(Util$dMap.mapObjectString.keys(d._2)))))(dataTypes))(Data$dList.identity)))();
+const dataTypeForCtr = {
+  dataTypeFor: dictMonadThrow => c => Util.orElse(dictMonadThrow)("Unknown constructor " + showCtr(c))(Foreign$dObject._lookup(
+    Data$dMaybe.Nothing,
+    Data$dMaybe.Just,
+    c,
+    ctrToDataType
+  ))
+};
+const dataTypeForSetCtr = {
+  dataTypeFor: dictMonadThrow => cs => {
+    const v = toUnfoldable(cs);
+    if (v.tag === "Cons") { return dataTypeForCtr.dataTypeFor(dictMonadThrow)(v._1); }
+    $runtime.fail();
+  }
+};
+const consistentWith = dictMonadError => {
+  const MonadThrow0 = dictMonadError.MonadThrow0();
+  const Bind1 = MonadThrow0.Monad0().Bind1();
+  const $$void = Bind1.Apply0().Functor0().map(v => {});
+  const withMsg = Util.withMsg(dictMonadError);
+  return cs => cs$p => $$void(Bind1.bind(dataTypeForSetCtr.dataTypeFor(MonadThrow0)(cs$p))(d => Bind1.bind(dataTypeForSetCtr.dataTypeFor(MonadThrow0)(cs$p))(d$p => withMsg("constructors of " + d$p._1 + " do not include " + show(Data$dSet.map(Data$dOrd.ordString)(showCtr)(cs)))(Util.mayFailEq(MonadThrow0)(showDataType)(eqDataType)(d)(d$p)))));
+};
+const arity = dictMonadThrow => c => dictMonadThrow.Monad0().Bind1().bind(dataTypeForCtr.dataTypeFor(dictMonadThrow)(c))(v => Util.orElse(dictMonadThrow)("absurd")(Foreign$dObject._lookup(
+  Data$dMaybe.Nothing,
+  Data$dMaybe.Just,
+  c,
+  v._2
+)));
+const checkArity = dictMonadError => {
+  const MonadThrow0 = dictMonadError.MonadThrow0();
+  const Monad0 = MonadThrow0.Monad0();
+  const $$void = Monad0.Bind1().Apply0().Functor0().map(v => {});
+  const withMsg = Util.withMsg(dictMonadError);
+  const bind2Flipped = Util.bind2Flipped(Monad0);
+  return c => n => $$void(withMsg("Checking arity of " + showCtr(c))(bind2Flipped(Util.mayFailEq(MonadThrow0)(Data$dShow.showInt)(Data$dEq.eqInt))(arity(MonadThrow0)(c))(Monad0.Applicative0().pure(n))));
+};
+export {
+  $DataType,
+  DataType,
+  arity,
+  cBarChart,
+  cCons,
+  cDefault,
+  cFalse,
+  cLineChart,
+  cLinePlot,
+  cLink,
+  cMultiView,
+  cNil,
+  cNone,
+  cPair,
+  cParagraph,
+  cRotated,
+  cScatterPlot,
+  cSome,
+  cText,
+  cTrue,
+  checkArity,
+  consistentWith,
+  ctrToDataType,
+  ctrs,
+  dataType,
+  dataTypeFor,
+  dataTypeForCtr,
+  dataTypeForSetCtr,
+  dataTypes,
+  eqDataType,
+  f_caption,
+  f_colour,
+  f_height,
+  f_labels,
+  f_legend,
+  f_name,
+  f_plots,
+  f_points,
+  f_segments,
+  f_size,
+  f_stackedBars,
+  f_tickLabels,
+  f_width,
+  f_x,
+  f_y,
+  f_z,
+  fromFoldable,
+  fromFoldable1,
+  isCtrName,
+  isCtrOp,
+  show,
+  showCtr,
+  showDataType,
+  toUnfoldable,
+  typeName
+};

package/output-es/Debug/foreign.js

@@ -0,0 +1,57 @@
+// Alias require to prevent webpack or browserify from actually requiring.
+const req = typeof module === "undefined" ? undefined : module.require;
+const util = (function() {
+  try {
+    return req === undefined ? undefined : req("util");
+  } catch(e) {
+    return undefined;
+  }
+})();
+
+export function _trace(x, k) {
+  // node only recurses two levels into an object before printing
+  // "[object]" for further objects when using console.log()
+  if (util !== undefined) {
+    console.log(util.inspect(x, { depth: null, colors: true }));
+  } else {
+    console.log(x);
+  }
+  return k({});
+}
+
+export function _spy(tag, x) {
+  if (util !== undefined) {
+    console.log(tag + ":", util.inspect(x, { depth: null, colors: true }));
+  } else {
+    console.log(tag + ":", x);
+  }
+  return x;
+}
+
+export function _debugger(f) {
+  debugger;
+  return f();
+
+}
+
+const now = (function () {
+  var perf;
+  if (typeof performance !== "undefined") {
+    // In browsers, `performance` is available in the global context
+    perf = performance;
+  } else if (req) {
+    // In Node, `performance` is an export of `perf_hooks`
+    try { perf = req("perf_hooks").performance; }
+    catch(e) { }
+  }
+
+  return (function() { return (perf || Date).now(); });
+})();
+
+export function _traceTime(name, f) {
+  var start = now();
+  var res = f();
+  var end = now();
+  console.log(name + " took " + (end - start) + "ms");
+  return res;
+}

package/output-es/Debug/index.js

@@ -0,0 +1,13 @@
+import {_debugger, _spy, _trace, _traceTime} from "./foreign.js";
+const warn = () => ({});
+const traceTime = () => $0 => $1 => _traceTime($0, $1);
+const trace = () => a => k => _trace(a, k);
+const traceM = () => dictMonad => {
+  const $0 = dictMonad.Applicative0();
+  return s => dictMonad.Bind1().bind($0.pure())(() => _trace(s, v => $0.pure()));
+};
+const spy = () => tag => a => _spy(tag, a);
+const spyWith = () => msg => f => a => a;
+const $$debugger = () => f => _debugger(f);
+export {$$debugger as debugger, spy, spyWith, trace, traceM, traceTime, warn};
+export * from "./foreign.js";

package/output-es/Desug/index.js

@@ -0,0 +1,17 @@
+import * as Control$dMonad$dExcept$dTrans from "../Control.Monad.Except.Trans/index.js";
+import * as Data$dIdentity from "../Data.Identity/index.js";
+import * as Lattice from "../Lattice/index.js";
+import * as SExpr from "../SExpr/index.js";
+import * as Util from "../Util/index.js";
+const desug1 = /* #__PURE__ */ (() => {
+  const $0 = {BoundedJoinSemilattice0: () => Lattice.boundedJoinSemilatticeUni, BoundedMeetSemilattice1: () => Lattice.boundedMeetSemilatticeUni};
+  return SExpr.exprFwd($0)(Control$dMonad$dExcept$dTrans.monadErrorExceptT(Data$dIdentity.monadIdentity))($0.BoundedJoinSemilattice0().JoinSemilattice0());
+})();
+const desugGC = dictMonadError => dictEq => dictBoundedLattice => {
+  const desug2 = SExpr.exprFwd(dictBoundedLattice)(Control$dMonad$dExcept$dTrans.monadErrorExceptT(Data$dIdentity.monadIdentity))(dictBoundedLattice.BoundedJoinSemilattice0().JoinSemilattice0());
+  return s => dictMonadError.MonadThrow0().Monad0().Applicative0().pure({
+    gc: {fwd: s$p => Util.defined(desug2(s$p)), bwd: e$p => SExpr.exprBwd(dictBoundedLattice.BoundedJoinSemilattice0())(e$p)(s)},
+    e: Util.defined(desug1(s))
+  });
+};
+export {desug1, desugGC};

package/output-es/Desugarable/index.js

@@ -0,0 +1,3 @@
+const desugBwd = dict => dict.desugBwd;
+const desug = dict => dict.desug;
+export {desug, desugBwd};

package/output-es/Dict/index.js

@@ -0,0 +1,118 @@
+// Better name and more consistent interface to Foreign.Object, plus some additional functions.
+// Newtype wrapper so we can fix Ord instance be consistent with Eq (i.e. to use isSubmap vs. toAscArray).
+import * as Data$dFoldable from "../Data.Foldable/index.js";
+import * as Data$dFoldableWithIndex from "../Data.FoldableWithIndex/index.js";
+import * as Data$dFunction from "../Data.Function/index.js";
+import * as Data$dMaybe from "../Data.Maybe/index.js";
+import * as Data$dOrdering from "../Data.Ordering/index.js";
+import * as Foreign$dObject from "../Foreign.Object/index.js";
+import * as Util$dMap from "../Util.Map/index.js";
+import * as Util$dSet from "../Util.Set/index.js";
+const identity = x => x;
+const Dict = x => x;
+const newtypeDict_ = {Coercible0: () => {}};
+const mapFDictString = {
+  intersectionWith: f => v => v1 => Util$dMap.intersectionWith_Object(f)(v)(v1),
+  difference: v => v1 => Util$dMap.mapFObjectString.difference(v)(v1),
+  mapWithKey: f => v => Foreign$dObject._mapWithKey(v, f)
+};
+const isEmptyDict = {isEmpty: v => Foreign$dObject.isEmpty(v)};
+const setDictString = {
+  empty: Foreign$dObject.empty,
+  filter: p => v => Foreign$dObject.filterWithKey(x => {
+    const $0 = p(x);
+    return v$1 => $0;
+  })(v),
+  size: v => Foreign$dObject.size(v),
+  member: x => v => Object.hasOwn(v, x),
+  difference: v => v1 => Util$dSet.setObjectString.difference(v)(v1),
+  union: v => v1 => Foreign$dObject.union(v)(v1),
+  IsEmpty0: () => isEmptyDict
+};
+const mapDictString = {
+  maplet: k => v => {
+    const $0 = {};
+    $0[k] = v;
+    return $0;
+  },
+  keys: v => Util$dMap.mapObjectString.keys(v),
+  values: v => Util$dMap.mapObjectString.values(v),
+  filterKeys: p => v => Foreign$dObject.filterWithKey(x => {
+    const $0 = p(x);
+    return v$1 => $0;
+  })(v),
+  unionWith: f => v => v1 => Foreign$dObject.unionWith(f)(v)(v1),
+  lookup: k => v => Foreign$dObject._lookup(Data$dMaybe.Nothing, Data$dMaybe.Just, k, v),
+  delete: k => v => Foreign$dObject.mutate($0 => () => {
+    delete $0[k];
+    return $0;
+  })(v),
+  insert: k => v => v1 => Foreign$dObject.mutate($0 => () => {
+    $0[k] = v;
+    return $0;
+  })(v1),
+  toUnfoldable: dictUnfoldable => Foreign$dObject.toAscUnfoldable(dictUnfoldable),
+  Set0: () => setDictString
+};
+const functorDict = {map: f => m => Foreign$dObject._fmapObject(m, f)};
+const foldableDict = {
+  foldl: f => z => m => Foreign$dObject.fold(z$1 => v => f(z$1))(z)(m),
+  foldr: f => z => m => Data$dFoldable.foldrArray(f)(z)(Foreign$dObject.values(m)),
+  foldMap: dictMonoid => {
+    const foldMap1 = Foreign$dObject.foldMap(dictMonoid);
+    return f => foldMap1(v => f);
+  }
+};
+const foldableWithIndexStringDi = {
+  foldlWithIndex: f => z => v => Foreign$dObject.fold(b => a => f(a)(b))(z)(v),
+  foldrWithIndex: f => Data$dFoldableWithIndex.foldrWithIndexDefault(foldableWithIndexStringDi)(f),
+  foldMapWithIndex: dictMonoid => f => foldableWithIndexStringDi.foldlWithIndex(i => acc => x => dictMonoid.Semigroup0().append(acc)(f(i)(x)))(dictMonoid.mempty),
+  Foldable0: () => foldableDict
+};
+const traversableDict = {
+  traverse: dictApplicative => {
+    const $0 = Foreign$dObject.traversableWithIndexObject.traverseWithIndex(dictApplicative);
+    return f => m => dictApplicative.Apply0().Functor0().map(v1 => v1)($0(v => f)(m));
+  },
+  sequence: dictApplicative => v => traversableDict.traverse(dictApplicative)(identity)(v),
+  Functor0: () => functorDict,
+  Foldable1: () => foldableDict
+};
+const eqDict = dictEq => Foreign$dObject.eqObject(dictEq);
+const ordDict = dictOrd => {
+  const Eq0 = dictOrd.Eq0();
+  const eqDict1 = Foreign$dObject.eqObject(Eq0);
+  return {
+    compare: v => v1 => {
+      if (Foreign$dObject.isSubmap(Eq0)(v)(v1)) {
+        if (Foreign$dObject.isSubmap(Eq0)(v1)(v)) { return Data$dOrdering.EQ; }
+        return Data$dOrdering.LT;
+      }
+      return Data$dOrdering.GT;
+    },
+    Eq0: () => eqDict1
+  };
+};
+const applyDict = {apply: v => v1 => Util$dMap.intersectionWith_Object(Data$dFunction.apply)(v)(v1), Functor0: () => functorDict};
+const unions = dictFoldable => dictFoldable.foldl(setDictString.union)(Foreign$dObject.empty);
+const toArrayWithKey = f => v => Foreign$dObject.toArrayWithKey(f)(v);
+const fromFoldable = dictFoldable => Foreign$dObject.fromFoldable(dictFoldable);
+export {
+  Dict,
+  applyDict,
+  eqDict,
+  foldableDict,
+  foldableWithIndexStringDi,
+  fromFoldable,
+  functorDict,
+  identity,
+  isEmptyDict,
+  mapDictString,
+  mapFDictString,
+  newtypeDict_,
+  ordDict,
+  setDictString,
+  toArrayWithKey,
+  traversableDict,
+  unions
+};

package/output-es/Effect/foreign.js

@@ -0,0 +1,51 @@
+export const pureE = function (a) {
+  return function () {
+    return a;
+  };
+};
+
+export const bindE = function (a) {
+  return function (f) {
+    return function () {
+      return f(a())();
+    };
+  };
+};
+
+export const untilE = function (f) {
+  return function () {
+    while (!f());
+  };
+};
+
+export const whileE = function (f) {
+  return function (a) {
+    return function () {
+      while (f()) {
+        a();
+      }
+    };
+  };
+};
+
+export const forE = function (lo) {
+  return function (hi) {
+    return function (f) {
+      return function () {
+        for (var i = lo; i < hi; i++) {
+          f(i)();
+        }
+      };
+    };
+  };
+};
+
+export const foreachE = function (as) {
+  return function (f) {
+    return function () {
+      for (var i = 0, l = as.length; i < l; i++) {
+        f(as[i])();
+      }
+    };
+  };
+};

package/output-es/Effect/index.js

@@ -0,0 +1,49 @@
+// | This module provides the `Effect` type, which is used to represent
+// | _native_ effects. The `Effect` type provides a typed API for effectful
+// | computations, while at the same time generating efficient JavaScript.
+import {bindE, forE, foreachE, pureE, untilE, whileE} from "./foreign.js";
+const monadEffect = {Applicative0: () => applicativeEffect, Bind1: () => bindEffect};
+const bindEffect = {bind: bindE, Apply0: () => applyEffect};
+const applyEffect = {
+  apply: f => a => () => {
+    const f$p = f();
+    const a$p = a();
+    return applicativeEffect.pure(f$p(a$p))();
+  },
+  Functor0: () => functorEffect
+};
+const applicativeEffect = {pure: pureE, Apply0: () => applyEffect};
+const functorEffect = {
+  map: f => a => () => {
+    const a$p = a();
+    return f(a$p);
+  }
+};
+const semigroupEffect = dictSemigroup => (
+  {
+    append: a => b => () => {
+      const a$p = a();
+      const a$p$1 = b();
+      return dictSemigroup.append(a$p)(a$p$1);
+    }
+  }
+);
+const monoidEffect = dictMonoid => {
+  const $0 = dictMonoid.Semigroup0();
+  const semigroupEffect1 = {
+    append: a => b => () => {
+      const a$p = a();
+      const a$p$1 = b();
+      return $0.append(a$p)(a$p$1);
+    }
+  };
+  return {
+    mempty: (() => {
+      const $1 = dictMonoid.mempty;
+      return () => $1;
+    })(),
+    Semigroup0: () => semigroupEffect1
+  };
+};
+export {applicativeEffect, applyEffect, bindEffect, functorEffect, monadEffect, monoidEffect, semigroupEffect};
+export * from "./foreign.js";