@explorable-viz/fluid 0.7.100 → 0.7.101

package/dist/fluid/shared/fluid.mjs

@@ -27,6 +27,75 @@ function intDiv(x, y) {
   return 0;
 }
 
+// output-es/Control.Monad.Reader.Trans/index.js
+var withReaderT = (f) => (v) => (x) => v(f(x));
+var bindReaderT = (dictBind) => {
+  const $0 = dictBind.Apply0();
+  const $1 = $0.Functor0();
+  const applyReaderT1 = (() => {
+    const functorReaderT1 = {
+      map: (x) => {
+        const $2 = $1.map(x);
+        return (v) => (x$1) => $2(v(x$1));
+      }
+    };
+    return { apply: (v) => (v1) => (r) => $0.apply(v(r))(v1(r)), Functor0: () => functorReaderT1 };
+  })();
+  return { bind: (v) => (k) => (r) => dictBind.bind(v(r))((a) => k(a)(r)), Apply0: () => applyReaderT1 };
+};
+var monadReaderT = (dictMonad) => {
+  const $0 = dictMonad.Applicative0();
+  const $1 = $0.Apply0();
+  const applicativeReaderT1 = (() => {
+    const $2 = $1.Functor0();
+    const functorReaderT1 = {
+      map: (x) => {
+        const $3 = $2.map(x);
+        return (v) => (x$1) => $3(v(x$1));
+      }
+    };
+    const applyReaderT1 = { apply: (v) => (v1) => (r) => $1.apply(v(r))(v1(r)), Functor0: () => functorReaderT1 };
+    return {
+      pure: (x) => {
+        const $3 = $0.pure(x);
+        return (v) => $3;
+      },
+      Apply0: () => applyReaderT1
+    };
+  })();
+  const bindReaderT1 = bindReaderT(dictMonad.Bind1());
+  return { Applicative0: () => applicativeReaderT1, Bind1: () => bindReaderT1 };
+};
+var monadReaderReaderT = (dictMonad) => {
+  const monadReaderT12 = monadReaderT(dictMonad);
+  const monadAskReaderT1 = { ask: dictMonad.Applicative0().pure, Monad0: () => monadReaderT12 };
+  return { local: withReaderT, MonadAsk0: () => monadAskReaderT1 };
+};
+var monadEffectReader = (dictMonadEffect) => {
+  const monadReaderT12 = monadReaderT(dictMonadEffect.Monad0());
+  return {
+    liftEffect: (x) => {
+      const $0 = dictMonadEffect.liftEffect(x);
+      return (v) => $0;
+    },
+    Monad0: () => monadReaderT12
+  };
+};
+var monadThrowReaderT = (dictMonadThrow) => {
+  const monadReaderT12 = monadReaderT(dictMonadThrow.Monad0());
+  return {
+    throwError: (x) => {
+      const $0 = dictMonadThrow.throwError(x);
+      return (v) => $0;
+    },
+    Monad0: () => monadReaderT12
+  };
+};
+var monadErrorReaderT = (dictMonadError) => {
+  const monadThrowReaderT1 = monadThrowReaderT(dictMonadError.MonadThrow0());
+  return { catchError: (v) => (h) => (r) => dictMonadError.catchError(v(r))((e) => h(e)(r)), MonadThrow0: () => monadThrowReaderT1 };
+};
+
 // output-es/Data.Function/index.js
 var $$const = (a) => (v) => a;
 var applyFlipped = (x) => (f) => f(x);
@@ -2599,45 +2668,6 @@ var force = function(l) {
   return l();
 };
 
-// output-es/Control.Monad.Reader.Trans/index.js
-var bindReaderT = (dictBind) => {
-  const $0 = dictBind.Apply0();
-  const $1 = $0.Functor0();
-  const applyReaderT1 = (() => {
-    const functorReaderT1 = {
-      map: (x) => {
-        const $2 = $1.map(x);
-        return (v) => (x$1) => $2(v(x$1));
-      }
-    };
-    return { apply: (v) => (v1) => (r) => $0.apply(v(r))(v1(r)), Functor0: () => functorReaderT1 };
-  })();
-  return { bind: (v) => (k) => (r) => dictBind.bind(v(r))((a) => k(a)(r)), Apply0: () => applyReaderT1 };
-};
-var monadReaderT = (dictMonad) => {
-  const $0 = dictMonad.Applicative0();
-  const $1 = $0.Apply0();
-  const applicativeReaderT1 = (() => {
-    const $2 = $1.Functor0();
-    const functorReaderT1 = {
-      map: (x) => {
-        const $3 = $2.map(x);
-        return (v) => (x$1) => $3(v(x$1));
-      }
-    };
-    const applyReaderT1 = { apply: (v) => (v1) => (r) => $1.apply(v(r))(v1(r)), Functor0: () => functorReaderT1 };
-    return {
-      pure: (x) => {
-        const $3 = $0.pure(x);
-        return (v) => $3;
-      },
-      Apply0: () => applyReaderT1
-    };
-  })();
-  const bindReaderT1 = bindReaderT(dictMonad.Bind1());
-  return { Applicative0: () => applicativeReaderT1, Bind1: () => bindReaderT1 };
-};
-
 // output-es/Control.Monad.State.Trans/index.js
 var evalStateT = (dictFunctor) => (v) => (s) => dictFunctor.map(fst)(v(s));
 var bindStateT = (dictMonad) => ({ bind: (v) => (f) => (s) => dictMonad.Bind1().bind(v(s))((v1) => f(v1._1)(v1._2)), Apply0: () => applyStateT(dictMonad) });
@@ -2653,6 +2683,27 @@ var applyStateT = (dictMonad) => {
   };
 };
 var applicativeStateT = (dictMonad) => ({ pure: (a) => (s) => dictMonad.Applicative0().pure($Tuple(a, s)), Apply0: () => applyStateT(dictMonad) });
+var monadAskStateT = (dictMonadAsk) => {
+  const Monad0 = dictMonadAsk.Monad0();
+  const monadStateT1 = { Applicative0: () => applicativeStateT(Monad0), Bind1: () => bindStateT(Monad0) };
+  return {
+    ask: (() => {
+      const $0 = dictMonadAsk.ask;
+      return (s) => Monad0.Bind1().bind($0)((x) => Monad0.Applicative0().pure($Tuple(x, s)));
+    })(),
+    Monad0: () => monadStateT1
+  };
+};
+var monadReaderStateT = (dictMonadReader) => {
+  const monadAskStateT1 = monadAskStateT(dictMonadReader.MonadAsk0());
+  return {
+    local: (x) => {
+      const $0 = dictMonadReader.local(x);
+      return (v) => (x$1) => $0(v(x$1));
+    },
+    MonadAsk0: () => monadAskStateT1
+  };
+};
 var monadEffectState = (dictMonadEffect) => {
   const Monad0 = dictMonadEffect.Monad0();
   const monadStateT1 = { Applicative0: () => applicativeStateT(Monad0), Bind1: () => bindStateT(Monad0) };
@@ -2702,6 +2753,16 @@ var monadErrorStateT = (dictMonadError) => {
 
 // output-es/Effect.Aff.Class/index.js
 var monadAffAff = { liftAff: (x) => x, MonadEffect0: () => monadEffectAff };
+var monadAffReader = (dictMonadAff) => {
+  const monadEffectReader2 = monadEffectReader(dictMonadAff.MonadEffect0());
+  return {
+    liftAff: (x) => {
+      const $0 = dictMonadAff.liftAff(x);
+      return (v) => $0;
+    },
+    MonadEffect0: () => monadEffectReader2
+  };
+};
 var monadAffState = (dictMonadAff) => {
   const MonadEffect0 = dictMonadAff.MonadEffect0();
   const monadEffectState2 = monadEffectState(MonadEffect0);
@@ -9559,7 +9620,7 @@ function _mapWithKey(m0, f) {
   }
   return m;
 }
-function _foldM(bind3) {
+function _foldM(bind4) {
   return function(f) {
     return function(mz) {
       return function(m) {
@@ -9571,7 +9632,7 @@ function _foldM(bind3) {
         }
         for (var k in m) {
           if (hasOwnProperty.call(m, k)) {
-            acc = bind3(acc)(g(k));
+            acc = bind4(acc)(g(k));
           }
         }
         return acc;
@@ -17962,8 +18023,8 @@ var isZeroNumber = { isZero: ($0) => 0 === $0 };
 var isZeroInt = { isZero: ($0) => 0 === $0 };
 var unary = (dictBoundedJoinSemilattice) => {
   const bot = dictBoundedJoinSemilattice.bot;
-  return (id) => (f) => $Tuple(
-    id,
+  return (id2) => (f) => $Tuple(
+    id2,
     $Val(
       bot,
       None,
@@ -17972,12 +18033,12 @@ var unary = (dictBoundedJoinSemilattice) => {
         $Fun(
           "Foreign",
           $Tuple(
-            id,
+            id2,
             $ForeignOp$p({
               arity: 1,
               op: (dictMonadWithGraphAlloc) => {
                 const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-                return (dictMonadError) => (dictLoadFile) => (v) => {
+                return (dictMonadError) => (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
                   if (v.tag === "Cons" && v._2.tag === "Nil") {
                     const $0 = v._1._2;
                     return $$new((a) => Val(a)($0))($$$Map("Two", Leaf2, v._1._1, void 0, Leaf2))(f.o.pack(f.fwd(f.i.unpack(v._1._3))));
@@ -18111,8 +18172,8 @@ var $$boolean = {
 };
 var binaryZero = (dictBoundedJoinSemilattice) => {
   const bot = dictBoundedJoinSemilattice.bot;
-  return (dictIsZero) => (id) => (f) => $Tuple(
-    id,
+  return (dictIsZero) => (id2) => (f) => $Tuple(
+    id2,
     $Val(
       bot,
       None,
@@ -18121,12 +18182,12 @@ var binaryZero = (dictBoundedJoinSemilattice) => {
         $Fun(
           "Foreign",
           $Tuple(
-            id,
+            id2,
             $ForeignOp$p({
               arity: 2,
               op: (dictMonadWithGraphAlloc) => {
                 const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-                return (dictMonadError) => (dictLoadFile) => (v) => {
+                return (dictMonadError) => (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
                   if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Nil") {
                     const $0 = f.i.unpack(v._1._3);
                     const $1 = f.i.unpack(v._2._1._3);
@@ -18159,8 +18220,8 @@ var binaryZero = (dictBoundedJoinSemilattice) => {
 };
 var binary = (dictBoundedJoinSemilattice) => {
   const bot = dictBoundedJoinSemilattice.bot;
-  return (id) => (f) => $Tuple(
-    id,
+  return (id2) => (f) => $Tuple(
+    id2,
     $Val(
       bot,
       None,
@@ -18169,12 +18230,12 @@ var binary = (dictBoundedJoinSemilattice) => {
         $Fun(
           "Foreign",
           $Tuple(
-            id,
+            id2,
             $ForeignOp$p({
               arity: 2,
               op: (dictMonadWithGraphAlloc) => {
                 const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-                return (dictMonadError) => (dictLoadFile) => (v) => {
+                return (dictMonadError) => (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
                   if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Nil") {
                     return $$new((a) => Val(a)(None))(insert(ordVertex)(v._2._1._1)()($$$Map(
                       "Two",
@@ -18374,23 +18435,28 @@ var closeDefs = (dictMonadWithGraphAlloc) => {
 };
 var new$p = (dictMonadWithGraphAlloc) => {
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
-  const MonadWithGraph2 = dictMonadWithGraphAlloc.MonadWithGraph2();
-  const Monad0 = MonadWithGraph2.Monad0();
-  const Bind1 = Monad0.Bind1();
   const fresh = dictMonadWithGraphAlloc.MonadAlloc0().fresh;
-  return (dictLoadFile) => (v) => (v1) => (v2) => (v3) => {
-    if (v2.tag === "None") {
-      return $$new((\u03B1s$p) => (u$p) => $Val(\u03B1s$p, None, u$p))(v1)(v3);
-    }
-    return Bind1.bind(fresh)((\u03B1) => Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith2((v$1) => identity13)(v)((() => {
-      const $0 = {};
-      $0.this = $Val(\u03B1, None, v3);
-      return $0;
-    })()))(v2))((vdoc) => Bind1.bind(MonadWithGraph2.extend($Tuple(\u03B1, pack3($Val(\u03B1, vdoc, v3))))(v1))(() => Monad0.Applicative0().pure($Val(\u03B1, vdoc, v3)))));
+  return (dictMonadReader) => (dictMonadAff) => {
+    const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+    const Bind1 = Monad0.Bind1();
+    return (dictLoadFile) => (v) => (v1) => (v2) => (v3) => {
+      if (v2.tag === "None") {
+        return $$new((\u03B1s$p) => (u$p) => $Val(\u03B1s$p, None, u$p))(v1)(v3);
+      }
+      return Bind1.bind(fresh)((\u03B1) => Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)((() => {
+        const $0 = {};
+        $0.this = $Val(\u03B1, None, v3);
+        return $0;
+      })()))(v2))((vdoc) => Bind1.bind(dictMonadWithGraphAlloc.MonadWithGraph2().extend($Tuple(\u03B1, pack3($Val(\u03B1, vdoc, v3))))(v1))(() => Monad0.Applicative0().pure($Val(
+        \u03B1,
+        vdoc,
+        v3
+      )))));
+    };
   };
 };
-var evalDocOpt = (dictMonadWithGraphAlloc) => {
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
+var evalDocOpt = (dictMonadWithGraphAlloc) => (dictMonadReader) => (dictMonadAff) => {
+  const Monad0 = dictMonadAff.MonadEffect0().Monad0();
   const Applicative0 = Monad0.Applicative0();
   const $0 = Monad0.Bind1().Apply0().Functor0();
   const sequence2 = traversableList.traverse(Applicative0)(identity5);
@@ -18404,7 +18470,7 @@ var evalDocOpt = (dictMonadWithGraphAlloc) => {
           return Applicative0.pure($DocCommentElem("Token", v2._1));
         }
         if (v2.tag === "Unquote") {
-          return $0.map(Unquote)($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v2._1)(setSet4.empty));
+          return $0.map(Unquote)($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v2._1)(setSet4.empty));
         }
         fail();
       })(v1._1)));
@@ -18416,195 +18482,210 @@ var $$eval = (dictMonadWithGraphAlloc) => {
   const MonadError1 = dictMonadWithGraphAlloc.MonadError1();
   const withMsg2 = withMsg(MonadError1);
   const MonadThrow0 = MonadError1.MonadThrow0();
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
-  const Bind1 = Monad0.Bind1();
-  const $0 = Bind1.Apply0().Functor0();
-  const Applicative0 = Monad0.Applicative0();
-  const traverse2 = traversableList.traverse(Applicative0);
-  const traverse3 = traversablePair.traverse(Applicative0);
   const checkArity2 = checkArity(MonadError1);
-  const sequence2 = traversableArray.traverse(Applicative0)(identity4);
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
   const match1 = match(dictMonadWithGraphAlloc);
   const closeDefs1 = closeDefs(dictMonadWithGraphAlloc);
-  return (dictLoadFile) => (v) => (v1) => (v2) => {
-    if (v1.tag === "Var") {
-      return withMsg2("Variable lookup")(lookup$p(MonadThrow0)(showString)(mapEnvStringVal)(v1._1)(v));
-    }
-    if (v1.tag === "Op") {
-      return withMsg2("Variable lookup")(lookup$p(MonadThrow0)(showString)(mapEnvStringVal)(v1._1)(v));
-    }
-    if (v1.tag === "Int") {
-      return new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal("Int", v1._3));
-    }
-    if (v1.tag === "Float") {
-      return new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal("Float", v1._3));
-    }
-    if (v1.tag === "Str") {
-      return new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal("Str", v1._3));
-    }
-    if (v1.tag === "Dictionary") {
-      const $1 = v1._2;
-      const $2 = v1._1;
-      return Bind1.bind($0.map(unzip3)(traverse2(traverse3((() => {
-        const $3 = $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v);
-        return (a) => $3(a)(v2);
-      })()))(v1._3)))((v3) => {
-        const v4 = unzip(listMap((v$1) => $Tuple(v$1._3.tag === "Str" ? v$1._3._1 : typeError(v$1._3)("Str"), v$1._1))(v3._1));
-        return new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert(ordVertex)($2)()(v2))($1)($BaseVal(
-          "Dictionary",
-          fromFoldable17(zipWith2(Tuple)(v4._1)(zipWith2(Tuple)(v4._2)(v3._2)))
+  return (dictMonadReader) => (dictMonadAff) => {
+    const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+    const Bind1 = Monad0.Bind1();
+    const $0 = Bind1.Apply0().Functor0();
+    const Applicative0 = Monad0.Applicative0();
+    const traverse2 = traversableList.traverse(Applicative0);
+    const traverse3 = traversablePair.traverse(Applicative0);
+    const sequence2 = traversableArray.traverse(Applicative0)(identity4);
+    return (dictLoadFile) => (v) => (v1) => (v2) => {
+      if (v1.tag === "Var") {
+        return withMsg2("Variable lookup")(lookup$p(MonadThrow0)(showString)(mapEnvStringVal)(v1._1)(v));
+      }
+      if (v1.tag === "Op") {
+        return withMsg2("Variable lookup")(lookup$p(MonadThrow0)(showString)(mapEnvStringVal)(v1._1)(v));
+      }
+      if (v1.tag === "Int") {
+        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal(
+          "Int",
+          v1._3
         ));
-      });
-    }
-    if (v1.tag === "Constr") {
-      const $1 = v1._3;
-      const $2 = v1._2;
-      const $3 = v1._4;
-      const $4 = v1._1;
-      return Bind1.bind(checkArity2($1)((() => {
-        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$1 = go$a1;
-            if (v$1.tag === "Nil") {
-              go$c = false;
-              go$r = b;
-              continue;
-            }
-            if (v$1.tag === "Cons") {
-              go$a0 = b + 1 | 0;
-              go$a1 = v$1._2;
-              continue;
+      }
+      if (v1.tag === "Float") {
+        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal(
+          "Float",
+          v1._3
+        ));
+      }
+      if (v1.tag === "Str") {
+        return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)(v1._1)()(v2))(v1._2)($BaseVal(
+          "Str",
+          v1._3
+        ));
+      }
+      if (v1.tag === "Dictionary") {
+        const $1 = v1._2;
+        const $2 = v1._1;
+        return Bind1.bind($0.map(unzip3)(traverse2(traverse3((() => {
+          const $3 = $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v);
+          return (a) => $3(a)(v2);
+        })()))(v1._3)))((v3) => {
+          const v4 = unzip(listMap((v$1) => $Tuple(v$1._3.tag === "Str" ? v$1._3._1 : typeError(v$1._3)("Str"), v$1._1))(v3._1));
+          return new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)($2)()(v2))($1)($BaseVal(
+            "Dictionary",
+            fromFoldable17(zipWith2(Tuple)(v4._1)(zipWith2(Tuple)(v4._2)(v3._2)))
+          ));
+        });
+      }
+      if (v1.tag === "Constr") {
+        const $1 = v1._3;
+        const $2 = v1._2;
+        const $3 = v1._4;
+        const $4 = v1._1;
+        return Bind1.bind(checkArity2($1)((() => {
+          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$1 = go$a1;
+              if (v$1.tag === "Nil") {
+                go$c = false;
+                go$r = b;
+                continue;
+              }
+              if (v$1.tag === "Cons") {
+                go$a0 = b + 1 | 0;
+                go$a1 = v$1._2;
+                continue;
+              }
+              fail();
             }
-            fail();
-          }
-          return go$r;
-        };
-        return go(0)($3);
-      })()))(() => Bind1.bind(traverse2((() => {
-        const $5 = $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v);
-        return (a) => $5(a)(v2);
-      })())($3))((vs) => new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert(ordVertex)($4)()(v2))($2)($BaseVal("Constr", $1, vs))));
-    }
-    if (v1.tag === "Matrix") {
-      const $1 = v1._2;
-      const $2 = v1._3;
-      const $3 = v1._4._1;
-      const $4 = v1._4._2;
-      const $5 = v1._1;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v1._5)(v2))((v3) => {
-        const v5 = intPair.unpack(v3._3);
-        const $6 = v5._1._1;
-        const $7 = v5._2._1;
-        const $8 = v5._1._2;
-        const $9 = v5._2._2;
-        return Bind1.bind(check(MonadThrow0)(greaterThanOrEq($Tuple($6, $7))($Tuple(1, 1)))("array must be at least (" + show3($Tuple(1, 1)) + "); got (" + show3($Tuple(
-          $6,
-          $7
-        )) + ")"))(() => Bind1.bind(sequence2(arrayBind(range(1)($6))((i) => [
-          sequence2(arrayBind(range(1)($7))((j) => [
-            $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith2((v$1) => identity13)(v)(disjointUnion2((() => {
-              const $10 = {};
-              $10[$3] = $Val($8, None, $BaseVal("Int", i));
-              return $10;
-            })())((() => {
-              const $10 = {};
-              $10[$4] = $Val($9, None, $BaseVal("Int", j));
-              return $10;
-            })())))($2)(v2)
-          ]))
-        ])))((vss) => new$p(dictMonadWithGraphAlloc)(dictLoadFile)(v)(insert(ordVertex)($5)()(v2))($1)($BaseVal(
-          "Matrix",
-          $Tuple(vss, $Tuple($Tuple($6, $8), $Tuple($7, $9)))
+            return go$r;
+          };
+          return go(0)($3);
+        })()))(() => Bind1.bind(traverse2((() => {
+          const $5 = $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v);
+          return (a) => $5(a)(v2);
+        })())($3))((vs) => new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)($4)()(v2))($2)($BaseVal(
+          "Constr",
+          $1,
+          vs
         ))));
-      });
-    }
-    if (v1.tag === "Lambda") {
-      return $$new((a) => Val(a)(None))(insert(ordVertex)(v1._1)()(v2))($BaseVal(
-        "Fun",
-        $Fun(
-          "Closure",
-          (() => {
-            const $1 = fVElim.fv(v1._2);
-            return filterWithKey2((x) => {
-              const $2 = setSet(ordString).member(x)($1);
-              return (v$1) => $2;
-            })(v);
-          })(),
-          empty,
-          v1._2
-        )
-      ));
-    }
-    if (v1.tag === "Project") {
-      const $1 = v1._1;
-      const $2 = v1._3;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v1._2)(v2))((v3) => {
-        if (v3._3.tag === "Dictionary") {
-          return Bind1.bind(withMsg2("Dict lookup")(orElse(MonadThrow0)('Key "' + $2 + '" not found')((() => {
-            const $3 = _lookup(Nothing, Just, $2, v3._3._1);
-            if ($3.tag === "Just") {
-              return $Maybe("Just", $3._1._2);
-            }
-            return Nothing;
-          })())))((v$p) => concatDocs(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v$p)($1));
-        }
-        return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v3)).lines) + ", expected dictionary"));
-      });
-    }
-    if (v1.tag === "DProject") {
-      const $1 = v1._1;
-      const $2 = v1._3;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)($2)(v2))((v$p) => {
-        if (v3._3.tag === "Dictionary") {
-          if (v$p._3.tag === "Str") {
-            return Bind1.bind(withMsg2("Dict lookup")(orElse(MonadThrow0)('Key "' + v$p._3._1 + '" not found')((() => {
-              const $3 = _lookup(Nothing, Just, v$p._3._1, v3._3._1);
+      }
+      if (v1.tag === "Matrix") {
+        const $1 = v1._2;
+        const $2 = v1._3;
+        const $3 = v1._4._1;
+        const $4 = v1._4._2;
+        const $5 = v1._1;
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._5)(v2))((v3) => {
+          const v5 = intPair.unpack(v3._3);
+          const $6 = v5._1._1;
+          const $7 = v5._2._1;
+          const $8 = v5._1._2;
+          const $9 = v5._2._2;
+          return Bind1.bind(check(MonadThrow0)(greaterThanOrEq($Tuple($6, $7))($Tuple(1, 1)))("array must be at least (" + show3($Tuple(
+            1,
+            1
+          )) + "); got (" + show3($Tuple($6, $7)) + ")"))(() => Bind1.bind(sequence2(arrayBind(range(1)($6))((i) => [
+            sequence2(arrayBind(range(1)($7))((j) => [
+              $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)(disjointUnion2((() => {
+                const $10 = {};
+                $10[$3] = $Val($8, None, $BaseVal("Int", i));
+                return $10;
+              })())((() => {
+                const $10 = {};
+                $10[$4] = $Val($9, None, $BaseVal("Int", j));
+                return $10;
+              })())))($2)(v2)
+            ]))
+          ])))((vss) => new$p(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(insert(ordVertex)($5)()(v2))($1)($BaseVal(
+            "Matrix",
+            $Tuple(vss, $Tuple($Tuple($6, $8), $Tuple($7, $9)))
+          ))));
+        });
+      }
+      if (v1.tag === "Lambda") {
+        return $$new((a) => Val(a)(None))(insert(ordVertex)(v1._1)()(v2))($BaseVal(
+          "Fun",
+          $Fun(
+            "Closure",
+            (() => {
+              const $1 = fVElim.fv(v1._2);
+              return filterWithKey2((x) => {
+                const $2 = setSet(ordString).member(x)($1);
+                return (v$1) => $2;
+              })(v);
+            })(),
+            empty,
+            v1._2
+          )
+        ));
+      }
+      if (v1.tag === "Project") {
+        const $1 = v1._1;
+        const $2 = v1._3;
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._2)(v2))((v3) => {
+          if (v3._3.tag === "Dictionary") {
+            return Bind1.bind(withMsg2("Dict lookup")(orElse(MonadThrow0)('Key "' + $2 + '" not found')((() => {
+              const $3 = _lookup(Nothing, Just, $2, v3._3._1);
               if ($3.tag === "Just") {
                 return $Maybe("Just", $3._1._2);
               }
               return Nothing;
-            })())))((v$p$p) => concatDocs(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v$p$p)($1));
+            })())))((v$p) => concatDocs(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v$p)($1));
           }
-          return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v$p)).lines) + ", expected string"));
-        }
-        return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v3)).lines) + ", expected dict"));
-      }));
-    }
-    if (v1.tag === "App") {
-      const $1 = v1._1;
-      const $2 = v1._3;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)($2)(v2))((v$p) => Bind1.bind(apply2(dictMonadWithGraphAlloc)(dictLoadFile)(v3)(v$p))((v4) => {
-        const $3 = v4._3;
-        const $4 = v4._1;
-        return Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith2((v$1) => identity13)(v)((() => {
-          const $5 = {};
-          $5.this = v4;
-          return $5;
-        })()))($1))((vdoc) => Applicative0.pure($Val($4, vdoc, $3)));
-      })));
-    }
-    if (v1.tag === "Let") {
-      const $1 = v1._2;
-      const $2 = v1._1._1;
-      return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictLoadFile)(v)(v1._1._2)(v2))((v3) => Bind1.bind(match1(v3)($2))((v4) => $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith2((v$1) => identity13)(v)(v4._1))($1)(v4._2._2)));
-    }
-    if (v1.tag === "LetRec") {
-      const $1 = v1._2;
-      const $2 = v1._1._1;
-      return Bind1.bind(closeDefs1(v)(v1._1._2)(insert(ordVertex)($2)()(v2)))((\u03B3$p) => $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith2((v$1) => identity13)(v)(\u03B3$p))($1)(insert(ordVertex)($2)()(v2)));
-    }
-    fail();
+          return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v3)).lines) + ", expected dictionary"));
+        });
+      }
+      if (v1.tag === "DProject") {
+        const $1 = v1._1;
+        const $2 = v1._3;
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)($2)(v2))((v$p) => {
+          if (v3._3.tag === "Dictionary") {
+            if (v$p._3.tag === "Str") {
+              return Bind1.bind(withMsg2("Dict lookup")(orElse(MonadThrow0)('Key "' + v$p._3._1 + '" not found')((() => {
+                const $3 = _lookup(Nothing, Just, v$p._3._1, v3._3._1);
+                if ($3.tag === "Just") {
+                  return $Maybe("Just", $3._1._2);
+                }
+                return Nothing;
+              })())))((v$p$p) => concatDocs(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v$p$p)($1));
+            }
+            return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v$p)).lines) + ", expected string"));
+          }
+          return MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v3)).lines) + ", expected dict"));
+        }));
+      }
+      if (v1.tag === "App") {
+        const $1 = v1._1;
+        const $2 = v1._3;
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._2)(v2))((v3) => Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)($2)(v2))((v$p) => Bind1.bind(apply2(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v3)(v$p))((v4) => {
+          const $3 = v4._3;
+          const $4 = v4._1;
+          return Bind1.bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)((() => {
+            const $5 = {};
+            $5.this = v4;
+            return $5;
+          })()))($1))((vdoc) => Applicative0.pure($Val($4, vdoc, $3)));
+        })));
+      }
+      if (v1.tag === "Let") {
+        const $1 = v1._2;
+        const $2 = v1._1._1;
+        return Bind1.bind($$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(v)(v1._1._2)(v2))((v3) => Bind1.bind(match1(v3)($2))((v4) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)(v4._1))($1)(v4._2._2)));
+      }
+      if (v1.tag === "LetRec") {
+        const $1 = v1._2;
+        const $2 = v1._1._1;
+        return Bind1.bind(closeDefs1(v)(v1._1._2)(insert(ordVertex)($2)()(v2)))((\u03B3$p) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(v)(\u03B3$p))($1)(insert(ordVertex)($2)()(v2)));
+      }
+      fail();
+    };
   };
 };
-var concatDocs = (dictMonadWithGraphAlloc) => {
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
+var concatDocs = (dictMonadWithGraphAlloc) => (dictMonadReader) => (dictMonadAff) => {
+  const Monad0 = dictMonadAff.MonadEffect0().Monad0();
   return (dictLoadFile) => (\u03B3) => (v) => (doc) => {
     const $0 = v._3;
     const $1 = v._2;
     const $2 = v._1;
-    return Monad0.Bind1().bind(evalDocOpt(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith2((v$1) => identity13)(\u03B3)((() => {
+    return Monad0.Bind1().bind(evalDocOpt(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(\u03B3)((() => {
       const $3 = {};
       $3.this = $Val($2, None, $0);
       return $3;
@@ -18612,163 +18693,183 @@ var concatDocs = (dictMonadWithGraphAlloc) => {
   };
 };
 var apply2 = (dictMonadWithGraphAlloc) => {
-  const Bind1 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0().Bind1();
   const closeDefs1 = closeDefs(dictMonadWithGraphAlloc);
   const match1 = match(dictMonadWithGraphAlloc);
   const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
   const MonadError1 = dictMonadWithGraphAlloc.MonadError1();
   const MonadThrow0 = MonadError1.MonadThrow0();
-  return (dictLoadFile) => (v) => (v1) => {
-    const $0 = (v2) => MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v2)).lines) + ", expected function"));
-    if (v._3.tag === "Fun") {
-      if (v._3._1.tag === "Closure") {
-        const $1 = v._1;
-        const $2 = v._3._1._1;
-        const $3 = v._3._1._3;
-        return Bind1.bind(closeDefs1($2)(v._3._1._2)($$$Map("Two", Leaf2, $1, void 0, Leaf2)))((\u03B32) => Bind1.bind(match1(v1)($3))((v3) => $$eval(dictMonadWithGraphAlloc)(dictLoadFile)(unionWith2((v$1) => identity13)(unionWith2((v$1) => identity13)($2)(\u03B32))(v3._1))(v3._2._1.tag === "ContExpr" ? v3._2._1._1 : throwException(error("Expression expected"))())(insert(ordVertex)($1)()(v3._2._2))));
-      }
-      if (v._3._1.tag === "Foreign") {
-        const $1 = v._3._1._1._2;
-        const vs$p = foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2);
-        if ((() => {
-          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$1 = go$a1;
-              if (v$1.tag === "Nil") {
-                go$c = false;
-                go$r = b;
-                continue;
-              }
-              if (v$1.tag === "Cons") {
-                go$a0 = b + 1 | 0;
-                go$a1 = v$1._2;
-                continue;
-              }
-              fail();
-            }
-            return go$r;
-          };
-          return $1._1.arity > go(0)(vs$p);
-        })()) {
-          return $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1, void 0, Leaf2))($BaseVal(
-            "Fun",
-            $Fun("Foreign", $Tuple(v._3._1._1._1, $1), vs$p)
-          ));
+  return (dictMonadReader) => (dictMonadAff) => {
+    const Bind1 = dictMonadAff.MonadEffect0().Monad0().Bind1();
+    return (dictLoadFile) => (v) => (v1) => {
+      const $0 = (v2) => MonadThrow0.throwError(error("Found " + intercalate4("\n")(removeDocWS(prettyVal(highlightableVertex).pretty(v2)).lines) + ", expected function"));
+      if (v._3.tag === "Fun") {
+        if (v._3._1.tag === "Closure") {
+          const $1 = v._1;
+          const $2 = v._3._1._1;
+          const $3 = v._3._1._3;
+          return Bind1.bind(closeDefs1($2)(v._3._1._2)($$$Map("Two", Leaf2, $1, void 0, Leaf2)))((\u03B32) => Bind1.bind(match1(v1)($3))((v3) => $$eval(dictMonadWithGraphAlloc)(dictMonadReader)(dictMonadAff)(dictLoadFile)(unionWith2((v$1) => identity13)(unionWith2((v$1) => identity13)($2)(\u03B32))(v3._1))(v3._2._1.tag === "ContExpr" ? v3._2._1._1 : throwException(error("Expression expected"))())(insert(ordVertex)($1)()(v3._2._2))));
         }
-        return $1._1.op(dictMonadWithGraphAlloc)(MonadError1)(dictLoadFile)(vs$p);
-      }
-      if (v._3._1.tag === "PartialConstr") {
-        const $1 = v._1;
-        const n = defined(arity(monadThrowExceptT(monadIdentity))(v._3._1._1));
-        const v$p = (() => {
-          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$1 = go$a1;
-              if (v$1.tag === "Nil") {
-                go$c = false;
-                go$r = b;
-                continue;
+        if (v._3._1.tag === "Foreign") {
+          const $1 = v._3._1._1._2;
+          const vs$p = foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2);
+          if ((() => {
+            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$1 = go$a1;
+                if (v$1.tag === "Nil") {
+                  go$c = false;
+                  go$r = b;
+                  continue;
+                }
+                if (v$1.tag === "Cons") {
+                  go$a0 = b + 1 | 0;
+                  go$a1 = v$1._2;
+                  continue;
+                }
+                fail();
               }
-              if (v$1.tag === "Cons") {
-                go$a0 = b + 1 | 0;
-                go$a1 = v$1._2;
-                continue;
+              return go$r;
+            };
+            return $1._1.arity > go(0)(vs$p);
+          })()) {
+            return $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1, void 0, Leaf2))($BaseVal(
+              "Fun",
+              $Fun("Foreign", $Tuple(v._3._1._1._1, $1), vs$p)
+            ));
+          }
+          return $1._1.op(dictMonadWithGraphAlloc)(MonadError1)(dictMonadAff)(dictMonadReader)(dictLoadFile)(vs$p);
+        }
+        if (v._3._1.tag === "PartialConstr") {
+          const $1 = v._1;
+          const n = defined(arity(monadThrowExceptT(monadIdentity))(v._3._1._1));
+          const v$p = (() => {
+            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$1 = go$a1;
+                if (v$1.tag === "Nil") {
+                  go$c = false;
+                  go$r = b;
+                  continue;
+                }
+                if (v$1.tag === "Cons") {
+                  go$a0 = b + 1 | 0;
+                  go$a1 = v$1._2;
+                  continue;
+                }
+                fail();
               }
-              fail();
-            }
-            return go$r;
-          };
-          return go(0)(v._3._1._2) < (n - 1 | 0);
-        })() ? $BaseVal(
-          "Fun",
-          $Fun(
-            "PartialConstr",
+              return go$r;
+            };
+            return go(0)(v._3._1._2) < (n - 1 | 0);
+          })() ? $BaseVal(
+            "Fun",
+            $Fun(
+              "PartialConstr",
+              v._3._1._1,
+              foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2)
+            )
+          ) : $BaseVal(
+            "Constr",
             v._3._1._1,
             foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2)
-          )
-        ) : $BaseVal("Constr", v._3._1._1, foldableList.foldr(Cons)($List("Cons", v1, Nil))(v._3._1._2));
-        return Bind1.bind(check(MonadThrow0)((() => {
-          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$1 = go$a1;
-              if (v$1.tag === "Nil") {
-                go$c = false;
-                go$r = b;
-                continue;
-              }
-              if (v$1.tag === "Cons") {
-                go$a0 = b + 1 | 0;
-                go$a1 = v$1._2;
-                continue;
+          );
+          return Bind1.bind(check(MonadThrow0)((() => {
+            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$1 = go$a1;
+                if (v$1.tag === "Nil") {
+                  go$c = false;
+                  go$r = b;
+                  continue;
+                }
+                if (v$1.tag === "Cons") {
+                  go$a0 = b + 1 | 0;
+                  go$a1 = v$1._2;
+                  continue;
+                }
+                fail();
               }
-              fail();
-            }
-            return go$r;
-          };
-          return go(0)(v._3._1._2) < n;
-        })())("Too many arguments to " + showCtr(v._3._1._1)))(() => $$new((a) => Val(a)(None))($$$Map(
-          "Two",
-          Leaf2,
-          $1,
-          void 0,
-          Leaf2
-        ))(v$p));
+              return go$r;
+            };
+            return go(0)(v._3._1._2) < n;
+          })())("Too many arguments to " + showCtr(v._3._1._1)))(() => $$new((a) => Val(a)(None))($$$Map(
+            "Two",
+            Leaf2,
+            $1,
+            void 0,
+            Leaf2
+          ))(v$p));
+        }
       }
-    }
-    return $0(v1);
+      return $0(v1);
+    };
   };
 };
 var eval_module = (dictMonadWithGraphAlloc) => {
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
-  const $0 = Monad0.Bind1();
   const eval1 = $$eval(dictMonadWithGraphAlloc);
   const match1 = match(dictMonadWithGraphAlloc);
   const closeDefs1 = closeDefs(dictMonadWithGraphAlloc);
-  return (dictLoadFile) => {
-    const eval2 = eval1(dictLoadFile);
-    return (\u03B3) => {
-      const go = (v) => (v1) => (v2) => {
-        if (v1.tag === "Nil") {
-          return Monad0.Applicative0().pure(v);
-        }
-        if (v1.tag === "Cons") {
-          if (v1._1.tag === "Left") {
-            const $1 = v1._2;
-            const $2 = v1._1._1._1;
-            return $0.bind(eval2(unionWith2((v$1) => identity13)(\u03B3)(v))(v1._1._1._2)(v2))((v3) => $0.bind(match1(v3)($2))((v4) => go(unionWith2((v$1) => identity13)(v)(v4._1))($1)(v4._2._2)));
-          }
-          if (v1._1.tag === "Right") {
-            const $1 = v1._2;
-            return $0.bind(closeDefs1(unionWith2((v$1) => identity13)(\u03B3)(v))(v1._1._1._2)(insert(ordVertex)(v1._1._1._1)()(v2)))((\u03B3$p$p) => go(unionWith2((v$1) => identity13)(v)(\u03B3$p$p))($1)(v2));
-          }
-        }
-        fail();
+  return (dictMonadReader) => {
+    const eval2 = eval1(dictMonadReader);
+    return (dictMonadAff) => {
+      const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+      const $0 = Monad0.Bind1();
+      const eval3 = eval2(dictMonadAff);
+      return (dictLoadFile) => {
+        const eval4 = eval3(dictLoadFile);
+        return (\u03B3) => {
+          const go = (v) => (v1) => (v2) => {
+            if (v1.tag === "Nil") {
+              return Monad0.Applicative0().pure(v);
+            }
+            if (v1.tag === "Cons") {
+              if (v1._1.tag === "Left") {
+                const $1 = v1._2;
+                const $2 = v1._1._1._1;
+                return $0.bind(eval4(unionWith2((v$1) => identity13)(\u03B3)(v))(v1._1._1._2)(v2))((v3) => $0.bind(match1(v3)($2))((v4) => go(unionWith2((v$1) => identity13)(v)(v4._1))($1)(v4._2._2)));
+              }
+              if (v1._1.tag === "Right") {
+                const $1 = v1._2;
+                return $0.bind(closeDefs1(unionWith2((v$1) => identity13)(\u03B3)(v))(v1._1._1._2)(insert(ordVertex)(v1._1._1._1)()(v2)))((\u03B3$p$p) => go(unionWith2((v$1) => identity13)(v)(\u03B3$p$p))($1)(v2));
+              }
+            }
+            fail();
+          };
+          return go(empty);
+        };
       };
-      return go(empty);
     };
   };
 };
 var eval_progCxt = (dictMonadWithGraphAlloc) => {
-  const Monad0 = dictMonadWithGraphAlloc.MonadWithGraph2().Monad0();
-  const $0 = Monad0.Bind1();
   const eval_module1 = eval_module(dictMonadWithGraphAlloc);
-  const $1 = Monad0.Applicative0();
   const eval1 = $$eval(dictMonadWithGraphAlloc);
-  const concatM1 = concatM(Monad0);
-  return (dictLoadFile) => {
-    const eval_module2 = eval_module1(dictLoadFile);
-    const eval2 = eval1(dictLoadFile);
-    return (v) => concatM1(foldableList.foldr(Cons)(listMap((v1) => (\u03B3) => {
-      const $2 = v1._1;
-      return $0.bind(eval2(\u03B3)(v1._2)(setSet4.empty))((v2) => $1.pure(unionWith2((v$1) => identity13)(\u03B3)((() => {
-        const $3 = {};
-        $3[$2] = v2;
-        return $3;
-      })())));
-    })(reverse2(v.datasets)))(listMap((mod) => (\u03B3) => $0.bind(eval_module2(\u03B3)(mod)(setSet4.empty))((\u03B3$p) => $1.pure(unionWith2((v$1) => identity13)(\u03B3)(\u03B3$p))))(reverse2(v.mods))))(v.primitives);
+  return (dictMonadReader) => {
+    const eval_module2 = eval_module1(dictMonadReader);
+    const eval2 = eval1(dictMonadReader);
+    return (dictMonadAff) => {
+      const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+      const $0 = Monad0.Bind1();
+      const eval_module3 = eval_module2(dictMonadAff);
+      const $1 = Monad0.Applicative0();
+      const eval3 = eval2(dictMonadAff);
+      const concatM1 = concatM(Monad0);
+      return (dictLoadFile) => {
+        const eval_module4 = eval_module3(dictLoadFile);
+        const eval4 = eval3(dictLoadFile);
+        return (v) => concatM1(foldableList.foldr(Cons)(listMap((v1) => (\u03B3) => {
+          const $2 = v1._1;
+          return $0.bind(eval4(\u03B3)(v1._2)(setSet4.empty))((v2) => $1.pure(unionWith2((v$1) => identity13)(\u03B3)((() => {
+            const $3 = {};
+            $3[$2] = v2;
+            return $3;
+          })())));
+        })(reverse2(v.datasets)))(listMap((mod) => (\u03B3) => $0.bind(eval_module4(\u03B3)(mod)(setSet4.empty))((\u03B3$p) => $1.pure(unionWith2((v$1) => identity13)(\u03B3)(\u03B3$p))))(reverse2(v.mods))))(v.primitives);
+      };
+    };
   };
 };
 var graphEval = (dictMonadAff) => {
@@ -18781,46 +18882,51 @@ var graphEval = (dictMonadAff) => {
     Applicative0: () => applicativeStateT(Monad0),
     Bind1: () => bindStateT(Monad0)
   })(graphGraphImpl);
-  const $1 = monadAffState(dictMonadAff).MonadEffect0().Monad0();
+  const monadAffState2 = monadAffState(dictMonadAff);
+  const monadAffState1 = monadAffState(monadAffState2);
+  const $1 = monadAffState2.MonadEffect0().Monad0();
   const $2 = dictMonadAff.MonadEffect0().Monad0();
-  return (dictLoadFile) => (dictMonadError) => {
-    const eval1 = $$eval(monadWithGraphAllocWithGr(dictMonadError))((() => {
-      const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
-      return {
-        loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
-          const $3 = loadFile1(folders);
-          return (x) => {
-            const $4 = $3(x);
-            return (s) => $1.Bind1().bind((s$1) => $2.Bind1().bind($4)((x$1) => $2.Applicative0().pure($Tuple(x$1, s$1))))((x$1) => $1.Applicative0().pure($Tuple(
-              x$1,
-              s
-            )));
-          };
-        }
+  return (dictMonadReader) => {
+    const monadReaderStateT2 = monadReaderStateT(monadReaderStateT(dictMonadReader));
+    return (dictLoadFile) => (dictMonadError) => {
+      const eval1 = $$eval(monadWithGraphAllocWithGr(dictMonadError))(monadReaderStateT2)(monadAffState1)((() => {
+        const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
+        return {
+          loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
+            const $3 = loadFile1(folders);
+            return (x) => {
+              const $4 = $3(x);
+              return (s) => $1.Bind1().bind((s$1) => $2.Bind1().bind($4)((x$1) => $2.Applicative0().pure($Tuple(x$1, s$1))))((x$1) => $1.Applicative0().pure($Tuple(
+                x$1,
+                s
+              )));
+            };
+          }
+        };
+      })());
+      const check2 = check(monadThrowStateT(dictMonadError.MonadThrow0()));
+      return (v) => (e) => {
+        const $3 = v["\u03B3"];
+        const $4 = spyFunWhen(false)("fwdSlice")((x) => $Tuple(showVertices(x._1), showEdgeList(toEdgeList(graphGraphImpl)(x._2))))(showGraph(graphGraphImpl))(fwdSlice2);
+        const $5 = spyFunWhen(false)("bwdSlice")((x) => $Tuple(showVertices(x._1), showEdgeList(toEdgeList(graphGraphImpl)(x._2))))(showGraph(graphGraphImpl))(bwdSlice2);
+        return Monad0.Bind1().bind(runAllocT(Monad0)(bindStateT2.bind(alloc(e))((e\u03B1) => bindStateT2.bind(runWithGraphT_spy2(eval1($3)(e\u03B1)(Leaf2))(verticesEnvExprVertex.vertices($EnvExpr(
+          $3,
+          e\u03B1
+        ))))((v1) => {
+          const $6 = v1._1;
+          const $7 = v1._2;
+          return bindStateT2.bind(check2(difference2(ordDVertex$p)(verticesValVertex.vertices($7))(verticesGraphImpl.vertices($6)).tag === "Leaf")("outputs in graph"))(() => applicativeStateT(Monad0).pure($Tuple(
+            $6,
+            $Tuple($EnvExpr($3, e\u03B1), $7)
+          )));
+        })))(v.n))((v1) => Monad0.Applicative0().pure({
+          g: v1._2._2._1,
+          graph_fwd: (a) => (b) => $4($Tuple(a, b)),
+          graph_bwd: (a) => (b) => $5($Tuple(a, b)),
+          "in\u03B1": v1._2._2._2._1,
+          "out\u03B1": v1._2._2._2._2
+        }));
       };
-    })());
-    const check2 = check(monadThrowStateT(dictMonadError.MonadThrow0()));
-    return (v) => (e) => {
-      const $3 = v["\u03B3"];
-      const $4 = spyFunWhen(false)("fwdSlice")((x) => $Tuple(showVertices(x._1), showEdgeList(toEdgeList(graphGraphImpl)(x._2))))(showGraph(graphGraphImpl))(fwdSlice2);
-      const $5 = spyFunWhen(false)("bwdSlice")((x) => $Tuple(showVertices(x._1), showEdgeList(toEdgeList(graphGraphImpl)(x._2))))(showGraph(graphGraphImpl))(bwdSlice2);
-      return Monad0.Bind1().bind(runAllocT(Monad0)(bindStateT2.bind(alloc(e))((e\u03B1) => bindStateT2.bind(runWithGraphT_spy2(eval1($3)(e\u03B1)(Leaf2))(verticesEnvExprVertex.vertices($EnvExpr(
-        $3,
-        e\u03B1
-      ))))((v1) => {
-        const $6 = v1._1;
-        const $7 = v1._2;
-        return bindStateT2.bind(check2(difference2(ordDVertex$p)(verticesValVertex.vertices($7))(verticesGraphImpl.vertices($6)).tag === "Leaf")("outputs in graph"))(() => applicativeStateT(Monad0).pure($Tuple(
-          $6,
-          $Tuple($EnvExpr($3, e\u03B1), $7)
-        )));
-      })))(v.n))((v1) => Monad0.Applicative0().pure({
-        g: v1._2._2._1,
-        graph_fwd: (a) => (b) => $4($Tuple(a, b)),
-        graph_bwd: (a) => (b) => $5($Tuple(a, b)),
-        "in\u03B1": v1._2._2._2._1,
-        "out\u03B1": v1._2._2._2._2
-      }));
     };
   };
 };
@@ -22971,7 +23077,7 @@ var matrixUpdate = /* @__PURE__ */ $Tuple(
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
         const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictLoadFile) => (v) => {
+        return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
           if (v.tag === "Cons" && v._1._3.tag === "Matrix" && v._2.tag === "Cons" && v._2._1._3.tag === "Constr" && v._2._1._3._2.tag === "Cons" && v._2._1._3._2._1._3.tag === "Int" && v._2._1._3._2._2.tag === "Cons" && v._2._1._3._2._2._1._3.tag === "Int" && v._2._1._3._2._2._2.tag === "Nil" && v._2._2.tag === "Cons" && v._2._2._2.tag === "Nil" && v._2._1._3._1 === "Pair") {
             const $0 = v._2._2._1;
             return $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1._1, void 0, Leaf2))($BaseVal(
@@ -22990,12 +23096,12 @@ var matrixLookup = /* @__PURE__ */ $Tuple(
   /* @__PURE__ */ $ForeignOp$p({
     arity: 2,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
-      const MonadThrow0 = dictMonadError.MonadThrow0();
-      return (dictLoadFile) => (v) => {
+      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._1._3.tag === "Matrix" && v._2.tag === "Cons" && v._2._1._3.tag === "Constr" && v._2._1._3._2.tag === "Cons" && v._2._1._3._2._1._3.tag === "Int" && v._2._1._3._2._2.tag === "Cons" && v._2._1._3._2._2._1._3.tag === "Int" && v._2._1._3._2._2._2.tag === "Nil" && v._2._2.tag === "Nil" && v._2._1._3._1 === "Pair") {
-          return MonadThrow0.Monad0().Applicative0().pure(matrixGet(v._2._1._3._2._1._3._1)(v._2._1._3._2._2._1._3._1)(v._1._3._1));
+          return dictMonadAff.MonadEffect0().Monad0().Applicative0().pure(matrixGet(v._2._1._3._2._1._3._1)(v._2._1._3._2._2._1._3._1)(v._1._3._1));
         }
-        return MonadThrow0.throwError(error("Matrix and pair of integers expected"));
+        return $$throw2("Matrix and pair of integers expected");
       };
     }
   })
@@ -23009,6 +23115,32 @@ var log3 = (v2) => {
   }
   fail();
 };
+var loadJson = /* @__PURE__ */ $Tuple(
+  "loadJson",
+  /* @__PURE__ */ $ForeignOp$p({
+    arity: 1,
+    op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
+      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+      return (dictMonadAff) => {
+        const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+        const $0 = Monad0.Bind1();
+        return (dictMonadReader) => {
+          const ask = dictMonadReader.MonadAsk0().ask;
+          return (dictLoadFile) => {
+            const loadFile = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
+            return (v) => {
+              if (v.tag === "Cons" && v._1._3.tag === "Str" && v._2.tag === "Nil") {
+                const $1 = v._1._3._1;
+                return $0.bind(ask)((v1) => $0.bind(loadFile(v1.fluidSrcPaths)($1))((str) => Monad0.Applicative0().pure(throwException(error($1))())));
+              }
+              return $$throw2("String expected");
+            };
+          };
+        };
+      };
+    }
+  })
+);
 var lessThanEquals = /* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asIntNumberOrString)(asIntNumberOrString)((a1) => (a2) => a1 <= a2)(/* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asNumberString)(asNumberString)((a1) => (a2) => a1 <= a2)((a1) => (a2) => a1 <= a2));
 var lessThan = /* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asIntNumberOrString)(asIntNumberOrString)((a1) => (a2) => a1 < a2)(/* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asNumberString)(asNumberString)((a1) => (a2) => a1 < a2)((a1) => (a2) => a1 < a2));
 var greaterThanEquals = /* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asIntNumberOrString)(asIntNumberOrString)((a1) => (a2) => a1 >= a2)(/* @__PURE__ */ union6(asBooleanBoolean)(asBooleanBoolean)(asNumberString)(asNumberString)((a1) => (a2) => a1 >= a2)((a1) => (a2) => a1 >= a2));
@@ -23023,12 +23155,12 @@ var error_ = /* @__PURE__ */ $Tuple(
   /* @__PURE__ */ $ForeignOp$p({
     arity: 1,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
-      const MonadThrow0 = dictMonadError.MonadThrow0();
-      return (dictLoadFile) => (v) => {
+      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._1._3.tag === "Str" && v._2.tag === "Nil") {
-          return MonadThrow0.Monad0().Applicative0().pure(throwException(error(v._1._3._1))());
+          return dictMonadAff.MonadEffect0().Monad0().Applicative0().pure(throwException(error(v._1._3._1))());
         }
-        return MonadThrow0.throwError(error("String expected"));
+        return $$throw2("String expected");
       };
     }
   })
@@ -23041,26 +23173,28 @@ var dims = /* @__PURE__ */ $Tuple(
     op: (dictMonadWithGraphAlloc) => {
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
-        const MonadThrow0 = dictMonadError.MonadThrow0();
-        const $0 = MonadThrow0.Monad0().Bind1();
-        return (dictLoadFile) => (v) => {
-          if (v.tag === "Cons" && v._1._3.tag === "Matrix" && v._2.tag === "Nil") {
-            const $1 = v._1._3._1._2._2._1;
-            const $2 = v._1._1;
-            const $3 = v._1._3._1._2._2._2;
-            return $0.bind($$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1._3._1._2._1._2, void 0, Leaf2))($BaseVal(
-              "Int",
-              v._1._3._1._2._1._1
-            )))((v1) => $0.bind($$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $3, void 0, Leaf2))($BaseVal(
-              "Int",
-              $1
-            )))((v2) => $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $2, void 0, Leaf2))($BaseVal(
-              "Constr",
-              "Pair",
-              $List("Cons", v1, $List("Cons", v2, Nil))
-            ))));
-          }
-          return MonadThrow0.throwError(error("Matrix expected"));
+        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+        return (dictMonadAff) => {
+          const $0 = dictMonadAff.MonadEffect0().Monad0().Bind1();
+          return (dictMonadReader) => (dictLoadFile) => (v) => {
+            if (v.tag === "Cons" && v._1._3.tag === "Matrix" && v._2.tag === "Nil") {
+              const $1 = v._1._3._1._2._2._1;
+              const $2 = v._1._1;
+              const $3 = v._1._3._1._2._2._2;
+              return $0.bind($$new((a) => Val(a)(None))($$$Map("Two", Leaf2, v._1._3._1._2._1._2, void 0, Leaf2))($BaseVal(
+                "Int",
+                v._1._3._1._2._1._1
+              )))((v1) => $0.bind($$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $3, void 0, Leaf2))($BaseVal(
+                "Int",
+                $1
+              )))((v2) => $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $2, void 0, Leaf2))($BaseVal(
+                "Constr",
+                "Pair",
+                $List("Cons", v1, $List("Cons", v2, Nil))
+              ))));
+            }
+            return $$throw2("Matrix expected");
+          };
         };
       };
     }
@@ -23074,25 +23208,30 @@ var dict_map = /* @__PURE__ */ $Tuple(
       const apply5 = apply2(dictMonadWithGraphAlloc);
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
-        const MonadThrow0 = dictMonadError.MonadThrow0();
-        const Monad0 = MonadThrow0.Monad0();
-        const Bind1 = Monad0.Bind1();
-        const traverse1 = traversableDict.traverse(Monad0.Applicative0());
-        return (dictLoadFile) => {
-          const apply12 = apply5(dictLoadFile);
-          return (v) => {
-            if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
-              const $0 = v._1;
-              const $1 = v._2._1._1;
-              return Bind1.bind(traverse1((v2) => {
-                const $2 = v2._1;
-                return Bind1.Apply0().Functor0().map((v3) => $Tuple($2, v3))(apply12($0)(v2._2));
-              })(v._2._1._3._1))((d$p) => $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $1, void 0, Leaf2))($BaseVal(
-                "Dictionary",
-                d$p
-              )));
-            }
-            return MonadThrow0.throwError(error("Function and dictionary expected"));
+        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+        return (dictMonadAff) => {
+          const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+          const Bind1 = Monad0.Bind1();
+          const traverse1 = traversableDict.traverse(Monad0.Applicative0());
+          return (dictMonadReader) => {
+            const apply12 = apply5(dictMonadReader)(dictMonadAff);
+            return (dictLoadFile) => {
+              const apply22 = apply12(dictLoadFile);
+              return (v) => {
+                if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
+                  const $0 = v._1;
+                  const $1 = v._2._1._1;
+                  return Bind1.bind(traverse1((v2) => {
+                    const $2 = v2._1;
+                    return Bind1.Apply0().Functor0().map((v3) => $Tuple($2, v3))(apply22($0)(v2._2));
+                  })(v._2._1._3._1))((d$p) => $$new((a) => Val(a)(None))($$$Map("Two", Leaf2, $1, void 0, Leaf2))($BaseVal(
+                    "Dictionary",
+                    d$p
+                  )));
+                }
+                return $$throw2("Function and dictionary expected");
+              };
+            };
           };
         };
       };
@@ -23107,38 +23246,43 @@ var dict_intersectionWith = /* @__PURE__ */ $Tuple(
       const apply5 = apply2(dictMonadWithGraphAlloc);
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
-        const MonadThrow0 = dictMonadError.MonadThrow0();
-        const Monad0 = MonadThrow0.Monad0();
-        const Bind1 = Monad0.Bind1();
-        const Applicative0 = Monad0.Applicative0();
-        const $0 = Bind1.Apply0().Functor0();
-        return (dictLoadFile) => {
-          const apply12 = apply5(dictLoadFile);
-          return (v) => {
-            if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Cons" && v._2._2._1._3.tag === "Dictionary" && v._2._2._2.tag === "Nil") {
-              const $1 = v._1;
-              const $2 = v._2._1._1;
-              const $3 = v._2._2._1._1;
-              return Bind1.bind($0.map(Dictionary3)($0.map(DictRep)(traversableDict.traverse(Applicative0)(identity14)(intersectionWith_Object((v2) => (v3) => {
-                const $4 = v3._2;
-                const $5 = v2._1;
-                const $6 = v3._1;
-                return Bind1.bind(Bind1.bind(apply12($1)(v2._2))((a) => apply12(a)($4)))((v4) => Bind1.bind($$new((a) => Val(a)(None))(insert(ordVertex)($6)()($$$Map(
-                  "Two",
-                  Leaf2,
-                  $5,
-                  void 0,
-                  Leaf2
-                )))(v4._3))((v5) => Applicative0.pure($Tuple(v5._1, v4))));
-              })(v._2._1._3._1)(v._2._2._1._3._1)))))((v$p) => $$new((a) => Val(a)(None))(insert(ordVertex)($3)()($$$Map(
-                "Two",
-                Leaf2,
-                $2,
-                void 0,
-                Leaf2
-              )))(v$p));
-            }
-            return MonadThrow0.throwError(error("Function and two dictionaries expected"));
+        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+        return (dictMonadAff) => {
+          const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+          const Bind1 = Monad0.Bind1();
+          const Applicative0 = Monad0.Applicative0();
+          const $0 = Bind1.Apply0().Functor0();
+          return (dictMonadReader) => {
+            const apply12 = apply5(dictMonadReader)(dictMonadAff);
+            return (dictLoadFile) => {
+              const apply22 = apply12(dictLoadFile);
+              return (v) => {
+                if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Cons" && v._2._2._1._3.tag === "Dictionary" && v._2._2._2.tag === "Nil") {
+                  const $1 = v._1;
+                  const $2 = v._2._1._1;
+                  const $3 = v._2._2._1._1;
+                  return Bind1.bind($0.map(Dictionary3)($0.map(DictRep)(traversableDict.traverse(Applicative0)(identity14)(intersectionWith_Object((v2) => (v3) => {
+                    const $4 = v3._2;
+                    const $5 = v2._1;
+                    const $6 = v3._1;
+                    return Bind1.bind(Bind1.bind(apply22($1)(v2._2))((a) => apply22(a)($4)))((v4) => Bind1.bind($$new((a) => Val(a)(None))(insert(ordVertex)($6)()($$$Map(
+                      "Two",
+                      Leaf2,
+                      $5,
+                      void 0,
+                      Leaf2
+                    )))(v4._3))((v5) => Applicative0.pure($Tuple(v5._1, v4))));
+                  })(v._2._1._3._1)(v._2._2._1._3._1)))))((v$p) => $$new((a) => Val(a)(None))(insert(ordVertex)($3)()($$$Map(
+                    "Two",
+                    Leaf2,
+                    $2,
+                    void 0,
+                    Leaf2
+                  )))(v$p));
+                }
+                return $$throw2("Function and two dictionaries expected");
+              };
+            };
           };
         };
       };
@@ -23151,7 +23295,7 @@ var dict_get = /* @__PURE__ */ $Tuple(
     arity: 2,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
       const MonadThrow0 = dictMonadError.MonadThrow0();
-      return (dictLoadFile) => (v) => {
+      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._1._3.tag === "Str" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
           return orElse(MonadThrow0)('Key "' + v._1._3._1 + '" not found')((() => {
             const $0 = _lookup(Nothing, Just, v._1._3._1, v._2._1._3._1);
@@ -23173,19 +23317,24 @@ var dict_foldl = /* @__PURE__ */ $Tuple(
     op: (dictMonadWithGraphAlloc) => {
       const apply5 = apply2(dictMonadWithGraphAlloc);
       return (dictMonadError) => {
-        const MonadThrow0 = dictMonadError.MonadThrow0();
-        const Monad0 = MonadThrow0.Monad0();
-        return (dictLoadFile) => {
-          const apply12 = apply5(dictLoadFile);
-          return (v) => {
-            if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Cons" && v._2._2._1._3.tag === "Dictionary" && v._2._2._2.tag === "Nil") {
-              const $0 = v._1;
-              return foldM4(Monad0)((u1) => (v2) => {
-                const $1 = v2._2;
-                return Monad0.Bind1().bind(apply12($0)(u1))((a) => apply12(a)($1));
-              })(v._2._1)(v._2._2._1._3._1);
-            }
-            return MonadThrow0.throwError(error("Function, value and dictionary expected"));
+        const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+        return (dictMonadAff) => {
+          const Monad0 = dictMonadAff.MonadEffect0().Monad0();
+          return (dictMonadReader) => {
+            const apply12 = apply5(dictMonadReader)(dictMonadAff);
+            return (dictLoadFile) => {
+              const apply22 = apply12(dictLoadFile);
+              return (v) => {
+                if (v.tag === "Cons" && v._2.tag === "Cons" && v._2._2.tag === "Cons" && v._2._2._1._3.tag === "Dictionary" && v._2._2._2.tag === "Nil") {
+                  const $0 = v._1;
+                  return foldM4(Monad0)((u1) => (v2) => {
+                    const $1 = v2._2;
+                    return Monad0.Bind1().bind(apply22($0)(u1))((a) => apply22(a)($1));
+                  })(v._2._1)(v._2._2._1._3._1);
+                }
+                return $$throw2("Function, value and dictionary expected");
+              };
+            };
           };
         };
       };
@@ -23200,7 +23349,7 @@ var dict_disjointUnion = /* @__PURE__ */ $Tuple(
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
         const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictLoadFile) => (v) => {
+        return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
           if (v.tag === "Cons" && v._1._3.tag === "Dictionary" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
             return $$new((a) => Val(a)(None))(insert(ordVertex)(v._2._1._1)()($$$Map(
               "Two",
@@ -23224,7 +23373,7 @@ var dict_difference = /* @__PURE__ */ $Tuple(
       const $$new = dictMonadWithGraphAlloc.new(typeNameVal);
       return (dictMonadError) => {
         const $$throw2 = $$throw(dictMonadError.MonadThrow0());
-        return (dictLoadFile) => (v) => {
+        return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
           if (v.tag === "Cons" && v._1._3.tag === "Dictionary" && v._2.tag === "Cons" && v._2._1._3.tag === "Dictionary" && v._2._2.tag === "Nil") {
             return $$new((a) => Val(a)(None))(insert(ordVertex)(v._2._1._1)()($$$Map(
               "Two",
@@ -23245,13 +23394,13 @@ var debugLog = /* @__PURE__ */ $Tuple(
   /* @__PURE__ */ $ForeignOp$p({
     arity: 1,
     op: (dictMonadWithGraphAlloc) => (dictMonadError) => {
-      const MonadThrow0 = dictMonadError.MonadThrow0();
-      return (dictLoadFile) => (v) => {
+      const $$throw2 = $$throw(dictMonadError.MonadThrow0());
+      return (dictMonadAff) => (dictMonadReader) => (dictLoadFile) => (v) => {
         if (v.tag === "Cons" && v._2.tag === "Nil") {
           const $0 = v._1;
-          return MonadThrow0.Monad0().Applicative0().pure(_trace($0, (v$1) => $0));
+          return dictMonadAff.MonadEffect0().Monad0().Applicative0().pure(_trace($0, (v$1) => $0));
         }
-        return MonadThrow0.throwError(error("Single value expected"));
+        return $$throw2("Single value expected");
       };
     }
   })
@@ -23265,6 +23414,7 @@ var primitives = /* @__PURE__ */ fromFoldable2(foldableArray)([
   /* @__PURE__ */ extern1(debugLog),
   /* @__PURE__ */ extern1(dims),
   /* @__PURE__ */ extern1(error_),
+  /* @__PURE__ */ extern1(loadJson),
   /* @__PURE__ */ unary2("floor")({ i: number, o: $$int, fwd: floor2 }),
   /* @__PURE__ */ unary2("log")({ i: intOrNumber, o: number, fwd: log3 }),
   /* @__PURE__ */ unary2("numToStr")({ i: intOrNumber, o: string, fwd: numToStr }),
@@ -23342,7 +23492,6 @@ var verticesProgCxtVertex = {
 };
 var functorProgCxt = {
   map: (f) => (m) => ({
-    fluidSrcPaths: m.fluidSrcPaths,
     primitives: _fmapObject(m.primitives, functorVal.map(f)),
     mods: listMap(functorModule.map(f))(m.mods),
     datasets: listMap((m$1) => $Tuple(m$1._1, functorExpr.map(f)(m$1._2)))(m.datasets)
@@ -23412,7 +23561,7 @@ var traversableProgCxt = {
     const traverse7 = traversableExpr.traverse(dictApplicative);
     const traverse8 = traversableModule.traverse(dictApplicative);
     const traverse9 = traversableEnv.traverse(dictApplicative);
-    return (f) => (m) => Apply0.apply(Apply0.apply(Apply0.Functor0().map((v1) => (v2) => (v3) => ({ fluidSrcPaths: m.fluidSrcPaths, primitives: v3, mods: v2, datasets: v1 }))(traverse5(traversableTuple.traverse(dictApplicative)(traverse7(f)))(m.datasets)))(traverse5(traverse8(f))(m.mods)))(traverse9(f)(m.primitives));
+    return (f) => (m) => Apply0.apply(Apply0.apply(Apply0.Functor0().map((v1) => (v2) => (v3) => ({ primitives: v3, mods: v2, datasets: v1 }))(traverse5(traversableTuple.traverse(dictApplicative)(traverse7(f)))(m.datasets)))(traverse5(traverse8(f))(m.mods)))(traverse9(f)(m.primitives));
   },
   sequence: (dictApplicative) => (v) => traversableProgCxt.traverse(dictApplicative)(identity25)(v),
   Functor0: () => functorProgCxt,
@@ -23458,7 +23607,6 @@ var module_2 = (dictMonadAff) => {
       return (folders) => (file) => (v) => {
         const $0 = v.mods;
         return Bind1.bind(Applicative0.pure())(() => Bind1.bind(loadFile(folders)(file))((src) => Bind1.bind(Bind1.bind(parse1(src)(module_))(desugarModuleFwd))((mod) => Applicative0.pure({
-          fluidSrcPaths: v.fluidSrcPaths,
           primitives: v.primitives,
           mods: $List("Cons", mod, $0),
           datasets: v.datasets
@@ -23479,36 +23627,41 @@ var initialConfig = (dictMonadAff) => {
     Applicative0: () => applicativeStateT(Monad0),
     Bind1: () => bindStateT(Monad0)
   })(graphGraphImpl);
-  const $2 = monadAffState(dictMonadAff).MonadEffect0().Monad0();
+  const monadAffState2 = monadAffState(dictMonadAff);
+  const monadAffState1 = monadAffState(monadAffState2);
+  const $2 = monadAffState2.MonadEffect0().Monad0();
   const $3 = dictMonadAff.MonadEffect0().Monad0();
   return (dictMonadError) => {
     const eval_progCxt2 = eval_progCxt(monadWithGraphAllocWithGr(dictMonadError));
-    return (dictLoadFile) => {
-      const eval_progCxt1 = eval_progCxt2((() => {
-        const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
-        return {
-          loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
-            const $4 = loadFile1(folders);
-            return (x) => {
-              const $5 = $4(x);
-              return (s) => $2.Bind1().bind((s$1) => $3.Bind1().bind($5)((x$1) => $3.Applicative0().pure($Tuple(x$1, s$1))))((x$1) => $2.Applicative0().pure($Tuple(
-                x$1,
-                s
-              )));
-            };
-          }
-        };
-      })());
-      return (dictFV) => (e) => (progCxt) => Bind1.bind(Applicative0.pure())(() => Bind1.bind(runAllocT(Monad0)($1.bind(alloc(progCxt))((progCxt$p) => $1.bind(runWithGraphT_spy2(eval_progCxt1(progCxt$p))(verticesProgCxtVertex.vertices(progCxt$p)))((v) => applicativeStateT(Monad0).pure($Tuple(
-        progCxt$p,
-        (() => {
-          const $4 = dictFV.fv(e);
-          return filterWithKey2((x) => {
-            const $5 = setSet(ordString).member(x)($4);
-            return (v$1) => $5;
-          })(v._2);
-        })()
-      )))))(0))((v) => Applicative0.pure({ n: v._1, progCxt: v._2._2._1, "\u03B3": v._2._2._2 })));
+    return (dictMonadReader) => {
+      const eval_progCxt1 = eval_progCxt2(monadReaderStateT(monadReaderStateT(dictMonadReader)))(monadAffState1);
+      return (dictLoadFile) => {
+        const eval_progCxt22 = eval_progCxt1((() => {
+          const loadFile1 = dictLoadFile.loadFile(dictMonadError)(dictMonadAff);
+          return {
+            loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => {
+              const $4 = loadFile1(folders);
+              return (x) => {
+                const $5 = $4(x);
+                return (s) => $2.Bind1().bind((s$1) => $3.Bind1().bind($5)((x$1) => $3.Applicative0().pure($Tuple(x$1, s$1))))((x$1) => $2.Applicative0().pure($Tuple(
+                  x$1,
+                  s
+                )));
+              };
+            }
+          };
+        })());
+        return (dictFV) => (e) => (progCxt) => Bind1.bind(Applicative0.pure())(() => Bind1.bind(runAllocT(Monad0)($1.bind(alloc(progCxt))((progCxt$p) => $1.bind(runWithGraphT_spy2(eval_progCxt22(progCxt$p))(verticesProgCxtVertex.vertices(progCxt$p)))((v) => applicativeStateT(Monad0).pure($Tuple(
+          progCxt$p,
+          (() => {
+            const $4 = dictFV.fv(e);
+            return filterWithKey2((x) => {
+              const $5 = setSet(ordString).member(x)($4);
+              return (v$1) => $5;
+            })(v._2);
+          })()
+        )))))(0))((v) => Applicative0.pure({ n: v._1, progCxt: v._2._2._1, "\u03B3": v._2._2._2 })));
+      };
     };
   };
 };
@@ -23519,13 +23672,17 @@ var prepConfig = (dictMonadAff) => {
   return (dictMonadError) => {
     const desug1 = exprFwd(boundedLattice2)(dictMonadError)(joinSemilatticeUnit);
     const initialConfig2 = initialConfig1(dictMonadError);
-    return (dictLoadFile) => {
-      const initialConfig3 = initialConfig2(dictLoadFile)(fVExpr);
-      return (v) => (file) => (progCxt) => $0.bind(parseProgram(dictLoadFile)(v.fluidSrcPaths)(file)(dictMonadAff)(dictMonadError))((s) => $0.bind(desug1(s))((e) => $0.bind(initialConfig3(e)(progCxt))((gconfig) => Monad0.Applicative0().pure({
-        s,
-        e,
-        gconfig
-      }))));
+    return (dictMonadReader) => {
+      const ask = dictMonadReader.MonadAsk0().ask;
+      const initialConfig3 = initialConfig2(dictMonadReader);
+      return (dictLoadFile) => {
+        const initialConfig4 = initialConfig3(dictLoadFile)(fVExpr);
+        return (file) => (progCxt) => $0.bind(ask)((v) => $0.bind(parseProgram(dictLoadFile)(v.fluidSrcPaths)(file)(dictMonadAff)(dictMonadError))((s) => $0.bind(desug1(s))((e) => $0.bind(initialConfig4(e)(progCxt))((gconfig) => Monad0.Applicative0().pure({
+          s,
+          e,
+          gconfig
+        })))));
+      };
     };
   };
 };
@@ -23538,7 +23695,6 @@ var datasetAs = (dictMonadAff) => {
       const $1 = v1.datasets;
       const $2 = v._1;
       return $0.bind($0.bind(parseProgram(dictLoadFile)(folders)(v._2)(dictMonadAff)(dictMonadError))(desug1))((e\u03B1) => Monad0.Applicative0().pure({
-        fluidSrcPaths: v1.fluidSrcPaths,
         primitives: v1.primitives,
         mods: v1.mods,
         datasets: $List("Cons", $Tuple($2, e\u03B1), $1)
@@ -23555,18 +23711,20 @@ var loadProgCxt = (dictMonadAff) => {
   return (dictMonadError) => {
     const module_22 = module_1(dictMonadError);
     const datasetAs2 = datasetAs1(dictMonadError);
-    return (dictLoadFile) => {
-      const module_3 = module_22(dictLoadFile);
-      const datasetAs3 = datasetAs2(dictLoadFile);
-      return (v) => (mods) => (datasets) => $0.bind($0.bind(Monad0.Applicative0().pure({
-        fluidSrcPaths: v.fluidSrcPaths,
-        primitives,
-        mods: Nil,
-        datasets: Nil
-      }))(concatM1(arrayMap(module_3(v.fluidSrcPaths))(["lib/prelude", ...mods]))))(concatM1(arrayMap((() => {
-        const $1 = datasetAs3(v.fluidSrcPaths);
-        return (x) => $1($Tuple(x._1, x._2));
-      })())(datasets)));
+    return (dictMonadReader) => {
+      const ask = dictMonadReader.MonadAsk0().ask;
+      return (dictLoadFile) => {
+        const module_3 = module_22(dictLoadFile);
+        const datasetAs3 = datasetAs2(dictLoadFile);
+        return (mods) => (datasets) => $0.bind(ask)((v) => $0.bind($0.bind(Monad0.Applicative0().pure({
+          primitives,
+          mods: Nil,
+          datasets: Nil
+        }))(concatM1(arrayMap(module_3(v.fluidSrcPaths))(["lib/prelude", ...mods]))))(concatM1(arrayMap((() => {
+          const $1 = datasetAs3(v.fluidSrcPaths);
+          return (x) => $1($Tuple(x._1, x._2));
+        })())(datasets))));
+      };
     };
   };
 };
@@ -23701,32 +23859,35 @@ var findM = (dictMonad) => {
   const $0 = dictMonad.Bind1().Apply0();
   return (dictFoldable) => (xs) => (f) => (base) => dictFoldable.foldr((x) => (acc) => $0.apply($0.Functor0().map(altMaybe.alt)(acc))(f(x)))(dictMonad.Applicative0().pure(base))(xs);
 };
-var loadFileNodeT = (dictMonadAff) => {
-  const Monad0 = dictMonadAff.MonadEffect0().Monad0();
-  const $0 = Monad0.Bind1();
-  const findM1 = findM(Monad0)(foldableArray);
-  return (dictMonadError) => ({
-    loadFile: (dictMonadError1) => (dictMonadAff1) => (folders) => (v) => $0.bind(findM1(arrayMap((() => {
+var loadFileNodeT = (dictMonad) => {
+  const bind4 = bindReaderT(dictMonad.Bind1()).bind;
+  const $0 = dictMonad.Applicative0();
+  const findM1 = findM(monadReaderT(dictMonad))(foldableArray);
+  return {
+    loadFile: (dictMonadError) => (dictMonadAff) => (folders) => (v) => bind4(findM1(arrayMap((() => {
       const $1 = v + ".fld";
       return (a) => a + "/" + $1;
-    })())(folders))((v1) => $0.bind(dictMonadAff1.liftAff($$try3(toAff1(stat2)(v1))))((stats) => Monad0.Applicative0().pure((() => {
-      if (stats.tag === "Left") {
-        return false;
-      }
-      if (stats.tag === "Right") {
-        return isFileImpl(stats._1);
-      }
-      fail();
-    })() ? $Maybe("Just", v1) : Nothing)))(Nothing))((url) => {
+    })())(folders))((v1) => bind4(dictMonadAff.liftAff($$try3(toAff1(stat2)(v1))))((stats) => {
+      const $1 = $0.pure((() => {
+        if (stats.tag === "Left") {
+          return false;
+        }
+        if (stats.tag === "Right") {
+          return isFileImpl(stats._1);
+        }
+        fail();
+      })() ? $Maybe("Just", v1) : Nothing);
+      return (v$1) => $1;
+    }))(Nothing))((url) => {
       if (url.tag === "Nothing") {
         return throwException(error("File " + v + " not found."))();
       }
       if (url.tag === "Just") {
-        return dictMonadAff1.liftAff(toAff2(readTextFile)(UTF8)(url._1));
+        return dictMonadAff.liftAff(toAff2(readTextFile)(UTF8)(url._1));
       }
       fail();
     })
-  });
+  };
 };
 
 // output-es/Options.Applicative.Internal.Utils/index.js
@@ -26892,10 +27053,14 @@ var execParserPure = (pprefs) => (pinfo) => (args) => {
 // output-es/Fluid/index.js
 var $Command = (_1) => ({ tag: "Evaluate", _1 });
 var $EvalArgs = (_1) => ({ tag: "EvalArgs", _1 });
-var loadFileNodeT2 = /* @__PURE__ */ loadFileNodeT(monadAffAff)(monadErrorAff);
-var loadProgCxt2 = /* @__PURE__ */ loadProgCxt(monadAffAff)(monadErrorAff)(loadFileNodeT2);
-var prepConfig2 = /* @__PURE__ */ prepConfig(monadAffAff)(monadErrorAff)(loadFileNodeT2);
-var graphEval2 = /* @__PURE__ */ graphEval(monadAffAff)(loadFileNodeT2)(monadErrorAff);
+var bind3 = /* @__PURE__ */ (() => bindReaderT(bindAff).bind)();
+var monadAffNodeT = /* @__PURE__ */ monadAffReader(monadAffAff);
+var monadErrorErrorNodeT = /* @__PURE__ */ monadErrorReaderT(monadErrorAff);
+var monadReaderFileCxtNodeT = /* @__PURE__ */ monadReaderReaderT(monadAff);
+var loadFileNodeT2 = /* @__PURE__ */ loadFileNodeT(monadAff);
+var loadProgCxt2 = /* @__PURE__ */ loadProgCxt(monadAffNodeT)(monadErrorErrorNodeT)(monadReaderFileCxtNodeT)(loadFileNodeT2);
+var prepConfig2 = /* @__PURE__ */ prepConfig(monadAffNodeT)(monadErrorErrorNodeT)(monadReaderFileCxtNodeT)(loadFileNodeT2);
+var graphEval2 = /* @__PURE__ */ graphEval(monadAffNodeT)(monadReaderFileCxtNodeT)(loadFileNodeT2)(monadErrorErrorNodeT);
 var fromFoldable25 = /* @__PURE__ */ (() => fromFoldableImpl(foldableList.foldr))();
 var Evaluate = (value0) => $Command(value0);
 var parseLocal = /* @__PURE__ */ $Parser(
@@ -26934,9 +27099,11 @@ var parseImports = /* @__PURE__ */ $Parser(
 );
 var evaluate = (v) => {
   const $0 = v._1.fileName;
-  const fluidSrcPaths = [v._1.fluidSrcPath, ...v._1.local ? ["node_modules/@explorable-viz/fluid/dist/fluid/fluid"] : []];
-  return _bind(loadProgCxt2({ fluidSrcPaths })(v._1.imports)(v._1.datasets))((progCxt) => _bind(prepConfig2({ fluidSrcPaths })($0)(progCxt))((v1) => _bind(graphEval2(v1.gconfig)(v1.e))((v2) => _pure(functorVal.map((v$1) => {
-  })(v2["out\u03B1"])))));
+  return bind3(loadProgCxt2(v._1.imports)(v._1.datasets))((progCxt) => bind3(prepConfig2($0)(progCxt))((v1) => bind3(graphEval2(v1.gconfig)(v1.e))((v2) => {
+    const $1 = _pure(functorVal.map((v$1) => {
+    })(v2["out\u03B1"]));
+    return (v$1) => $1;
+  })))({ fluidSrcPaths: [v._1.fluidSrcPath, ...v._1.local ? ["node_modules/@explorable-viz/fluid/dist/fluid/fluid"] : []] });
 };
 var dispatchCommand = (v) => _bind(evaluate(v._1))((v1) => _liftEffect(log(intercalate4("\n")(removeDocWS(prettyVal(highlightableUnit).pretty(v1)).lines))));
 var callback = (v) => {