Ran yarn format

packages/squiggle-lang/__tests__/Distributions/Invariants/AlgebraicCombination_test.res

@@ -25,7 +25,7 @@ let {
   algebraicDivide,
   algebraicSubtract,
   algebraicLogarithm,
-    algebraicPower
+  algebraicPower,
 } = module(DistributionOperation.Constructors)
 
 let algebraicAdd = algebraicAdd(~env)
@@ -36,282 +36,329 @@ let algebraicLogarithm = algebraicLogarithm(~env)
 let algebraicPower = algebraicPower(~env)
 
 describe("(Algebraic) addition of distributions", () => {
-
   describe("mean", () => {
     test("normal(mean=5) + normal(mean=20)", () => {
       normalDist5
-            -> algebraicAdd(normalDist20)
-            -> E.R2.fmap(GenericDist_Types.Constructors.UsingDists.mean)
-            -> E.R2.fmap(run)
-            -> E.R2.fmap(toFloat)
-            -> E.R.toExn
-            -> expect
-            -> toBe(Some(2.5e1))
+      ->algebraicAdd(normalDist20)
+      ->E.R2.fmap(GenericDist_Types.Constructors.UsingDists.mean)
+      ->E.R2.fmap(run)
+      ->E.R2.fmap(toFloat)
+      ->E.R.toExn
+      ->expect
+      ->toBe(Some(2.5e1))
     })
 
     test("uniform(low=9, high=10) + beta(alpha=2, beta=5)", () => {
       // let uniformMean = (9.0 +. 10.0) /. 2.0
       // let betaMean = 1.0 /. (1.0 +. 5.0 /. 2.0)
-            let received = uniformDist 
-                -> algebraicAdd(betaDist)
-                -> E.R2.fmap(GenericDist_Types.Constructors.UsingDists.mean)
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toExn
+      let received =
+        uniformDist
+        ->algebraicAdd(betaDist)
+        ->E.R2.fmap(GenericDist_Types.Constructors.UsingDists.mean)
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toExn
       switch received {
-                | None => "algebraicAdd has" -> expect -> toBe("failed")
+      | None => "algebraicAdd has"->expect->toBe("failed")
       // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
       // sometimes it works with ~digits=2.
-                | Some(x) => x -> expect -> toBeSoCloseTo(0.01927225696028752, ~digits=1)  // (uniformMean +. betaMean)
+      | Some(x) => x->expect->toBeSoCloseTo(0.01927225696028752, ~digits=1) // (uniformMean +. betaMean)
       }
     })
     test("beta(alpha=2, beta=5) + uniform(low=9, high=10)", () => {
       // let uniformMean = (9.0 +. 10.0) /. 2.0
       // let betaMean = 1.0 /. (1.0 +. 5.0 /. 2.0)
-            let received = betaDist 
-                -> algebraicAdd(uniformDist)
-                -> E.R2.fmap(GenericDist_Types.Constructors.UsingDists.mean)
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toExn
+      let received =
+        betaDist
+        ->algebraicAdd(uniformDist)
+        ->E.R2.fmap(GenericDist_Types.Constructors.UsingDists.mean)
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toExn
       switch received {
-                | None => "algebraicAdd has" -> expect -> toBe("failed")
+      | None => "algebraicAdd has"->expect->toBe("failed")
       // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
       // sometimes it works with ~digits=2.
-                | Some(x) => x -> expect -> toBeSoCloseTo(0.019275414920485248, ~digits=1)  // (uniformMean +. betaMean)
+      | Some(x) => x->expect->toBeSoCloseTo(0.019275414920485248, ~digits=1) // (uniformMean +. betaMean)
       }
     })
   })
   describe("pdf", () => {
     // TEST IS WRONG. SEE STDEV ADDITION EXPRESSION.
-        testAll("(normal(mean=5) + normal(mean=5)).pdf (imprecise)", list{8e0, 1e1, 1.2e1, 1.4e1}, x => {
-            let received = normalDist10  // this should be normal(10, sqrt(8))
-                -> Ok 
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, x))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
-            let calculated = normalDist5
-                -> algebraicAdd(normalDist5)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, x))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
+    testAll(
+      "(normal(mean=5) + normal(mean=5)).pdf (imprecise)",
+      list{8e0, 1e1, 1.2e1, 1.4e1},
+      x => {
+        let received =
+          normalDist10 // this should be normal(10, sqrt(8))
+          ->Ok
+          ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, x))
+          ->E.R2.fmap(run)
+          ->E.R2.fmap(toFloat)
+          ->E.R.toOption
+          ->E.O.flatten
+        let calculated =
+          normalDist5
+          ->algebraicAdd(normalDist5)
+          ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, x))
+          ->E.R2.fmap(run)
+          ->E.R2.fmap(toFloat)
+          ->E.R.toOption
+          ->E.O.flatten
 
         switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
-                | Some(x) => switch calculated {
-                    | None => "algebraicAdd has" -> expect -> toBe("failed")
-                    | Some(y) => x -> expect -> toBeSoCloseTo(y, ~digits=0)
+        | None =>
+          "this branch occurs when the dispatch to Jstat on trusted input fails."
+          ->expect
+          ->toBe("never")
+        | Some(x) =>
+          switch calculated {
+          | None => "algebraicAdd has"->expect->toBe("failed")
+          | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=0)
           }
         }
-        })
+      },
+    )
     test("(normal(mean=10) + normal(mean=10)).pdf(1.9e1)", () => {
-            let received = normalDist20
-                -> Ok
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1.9e1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
-            let calculated = normalDist10
-                -> algebraicAdd(normalDist10)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1.9e1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
+      let received =
+        normalDist20
+        ->Ok
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1.9e1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
+      let calculated =
+        normalDist10
+        ->algebraicAdd(normalDist10)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1.9e1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
-                | Some(x) => switch calculated {
-                    | None => "algebraicAdd has" -> expect -> toBe("failed")
-                    | Some(y) => x -> expect -> toBeSoCloseTo(y, ~digits=1)
+      | None =>
+        "this branch occurs when the dispatch to Jstat on trusted input fails."
+        ->expect
+        ->toBe("never")
+      | Some(x) =>
+        switch calculated {
+        | None => "algebraicAdd has"->expect->toBe("failed")
+        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=1)
         }
       }
     })
     test("(uniform(low=9, high=10) + beta(alpha=2, beta=5)).pdf(10)", () => {
-            let received = uniformDist 
-                -> algebraicAdd(betaDist)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1e1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toExn
+      let received =
+        uniformDist
+        ->algebraicAdd(betaDist)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1e1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toExn
       switch received {
-                | None => "algebraicAdd has" -> expect -> toBe("failed")
+      | None => "algebraicAdd has"->expect->toBe("failed")
       // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
       // sometimes it works with ~digits=4.
-                | Some(x) => x -> expect -> toBeSoCloseTo(0.001978994877226945, ~digits=3)  
+      | Some(x) => x->expect->toBeSoCloseTo(0.001978994877226945, ~digits=3)
       }
     })
     test("(beta(alpha=2, beta=5) + uniform(low=9, high=10)).pdf(10)", () => {
-            let received = betaDist 
-                -> algebraicAdd(uniformDist)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1e1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toExn
+      let received =
+        betaDist
+        ->algebraicAdd(uniformDist)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1e1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toExn
       switch received {
-                | None => "algebraicAdd has" -> expect -> toBe("failed")
+      | None => "algebraicAdd has"->expect->toBe("failed")
       // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
       // sometimes it works with ~digits=4.
-                | Some(x) => x -> expect -> toBeSoCloseTo(0.001978994877226945, ~digits=3) 
+      | Some(x) => x->expect->toBeSoCloseTo(0.001978994877226945, ~digits=3)
       }
     })
   })
   describe("cdf", () => {
     testAll("(normal(mean=5) + normal(mean=5)).cdf (imprecise)", list{6e0, 8e0, 1e1, 1.2e1}, x => {
-            let received = normalDist10
-                -> Ok 
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, x))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
-            let calculated = normalDist5
-                -> algebraicAdd(normalDist5)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, x))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
+      let received =
+        normalDist10
+        ->Ok
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, x))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
+      let calculated =
+        normalDist5
+        ->algebraicAdd(normalDist5)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, x))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
 
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
-                | Some(x) => switch calculated {
-                    | None => "algebraicAdd has" -> expect -> toBe("failed")
-                    | Some(y) => x -> expect -> toBeSoCloseTo(y, ~digits=0)
+      | None =>
+        "this branch occurs when the dispatch to Jstat on trusted input fails."
+        ->expect
+        ->toBe("never")
+      | Some(x) =>
+        switch calculated {
+        | None => "algebraicAdd has"->expect->toBe("failed")
+        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=0)
         }
       }
     })
     test("(normal(mean=10) + normal(mean=10)).cdf(1.25e1)", () => {
-            let received = normalDist20
-                -> Ok
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1.25e1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
-            let calculated = normalDist10
-                -> algebraicAdd(normalDist10)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1.25e1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
+      let received =
+        normalDist20
+        ->Ok
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1.25e1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
+      let calculated =
+        normalDist10
+        ->algebraicAdd(normalDist10)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1.25e1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
-                | Some(x) => switch calculated {
-                    | None => "algebraicAdd has" -> expect -> toBe("failed")
-                    | Some(y) => x -> expect -> toBeSoCloseTo(y, ~digits=2)
+      | None =>
+        "this branch occurs when the dispatch to Jstat on trusted input fails."
+        ->expect
+        ->toBe("never")
+      | Some(x) =>
+        switch calculated {
+        | None => "algebraicAdd has"->expect->toBe("failed")
+        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=2)
         }
       }
     })
     test("(uniform(low=9, high=10) + beta(alpha=2, beta=5)).cdf(10)", () => {
-            let received = uniformDist 
-                -> algebraicAdd(betaDist)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1e1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toExn
+      let received =
+        uniformDist
+        ->algebraicAdd(betaDist)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1e1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toExn
       switch received {
-                | None => "algebraicAdd has" -> expect -> toBe("failed")
+      | None => "algebraicAdd has"->expect->toBe("failed")
       // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
       // sometimes it works with ~digits=4.
-                | Some(x) => x -> expect -> toBeSoCloseTo(0.0013961779932477507, ~digits=4)
+      | Some(x) => x->expect->toBeSoCloseTo(0.0013961779932477507, ~digits=4)
       }
     })
     test("(beta(alpha=2, beta=5) + uniform(low=9, high=10)).cdf(10)", () => {
-            let received = betaDist 
-                -> algebraicAdd(uniformDist)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1e1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toExn
+      let received =
+        betaDist
+        ->algebraicAdd(uniformDist)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1e1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toExn
       switch received {
-                | None => "algebraicAdd has" -> expect -> toBe("failed")
+      | None => "algebraicAdd has"->expect->toBe("failed")
       // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
       // sometimes it works with ~digits=4.
-                | Some(x) => x -> expect -> toBeSoCloseTo(0.001388898111625753, ~digits=3)
+      | Some(x) => x->expect->toBeSoCloseTo(0.001388898111625753, ~digits=3)
       }
     })
   })
 
   describe("inv", () => {
     testAll("(normal(mean=5) + normal(mean=5)).inv (imprecise)", list{5e-2, 4.2e-3, 9e-3}, x => {
-            let received = normalDist10
-                -> Ok 
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, x))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
-            let calculated = normalDist5
-                -> algebraicAdd(normalDist5)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, x))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
+      let received =
+        normalDist10
+        ->Ok
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, x))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
+      let calculated =
+        normalDist5
+        ->algebraicAdd(normalDist5)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, x))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
 
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
-                | Some(x) => switch calculated {
-                    | None => "algebraicAdd has" -> expect -> toBe("failed")
-                    | Some(y) => x -> expect -> toBeSoCloseTo(y, ~digits=-1)
+      | None =>
+        "this branch occurs when the dispatch to Jstat on trusted input fails."
+        ->expect
+        ->toBe("never")
+      | Some(x) =>
+        switch calculated {
+        | None => "algebraicAdd has"->expect->toBe("failed")
+        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=-1)
         }
       }
     })
     test("(normal(mean=10) + normal(mean=10)).inv(1e-1)", () => {
-            let received = normalDist20
-                -> Ok
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 1e-1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
-            let calculated = normalDist10
-                -> algebraicAdd(normalDist10)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 1e-1))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toOption
-                -> E.O.flatten
+      let received =
+        normalDist20
+        ->Ok
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 1e-1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
+      let calculated =
+        normalDist10
+        ->algebraicAdd(normalDist10)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 1e-1))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toOption
+        ->E.O.flatten
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
-                | Some(x) => switch calculated {
-                    | None => "algebraicAdd has" -> expect -> toBe("failed")
-                    | Some(y) => x -> expect -> toBeSoCloseTo(y, ~digits=-1)
+      | None =>
+        "this branch occurs when the dispatch to Jstat on trusted input fails."
+        ->expect
+        ->toBe("never")
+      | Some(x) =>
+        switch calculated {
+        | None => "algebraicAdd has"->expect->toBe("failed")
+        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=-1)
         }
       }
     })
     test("(uniform(low=9, high=10) + beta(alpha=2, beta=5)).inv(2e-2)", () => {
-            let received = uniformDist 
-                -> algebraicAdd(betaDist)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 2e-2))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toExn
+      let received =
+        uniformDist
+        ->algebraicAdd(betaDist)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 2e-2))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toExn
       switch received {
-                | None => "algebraicAdd has" -> expect -> toBe("failed")
+      | None => "algebraicAdd has"->expect->toBe("failed")
       // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
       // sometimes it works with ~digits=2.
-                | Some(x) => x -> expect -> toBeSoCloseTo(10.927078217530806, ~digits=1)
+      | Some(x) => x->expect->toBeSoCloseTo(10.927078217530806, ~digits=1)
       }
     })
     test("(beta(alpha=2, beta=5) + uniform(low=9, high=10)).inv(2e-2)", () => {
-            let received = betaDist 
-                -> algebraicAdd(uniformDist)
-                -> E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 2e-2))
-                -> E.R2.fmap(run)
-                -> E.R2.fmap(toFloat)
-                -> E.R.toExn
+      let received =
+        betaDist
+        ->algebraicAdd(uniformDist)
+        ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 2e-2))
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
+        ->E.R.toExn
       switch received {
-                | None => "algebraicAdd has" -> expect -> toBe("failed")
+      | None => "algebraicAdd has"->expect->toBe("failed")
       // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
       // sometimes it works with ~digits=2.
-                | Some(x) => x -> expect -> toBeSoCloseTo(10.915396627014363, ~digits=0)
+      | Some(x) => x->expect->toBeSoCloseTo(10.915396627014363, ~digits=0)
       }
     })
   })

packages/squiggle-lang/__tests__/Distributions/Invariants/Means_test.res

@@ -8,7 +8,7 @@ let {
   algebraicDivide,
   algebraicSubtract,
   algebraicLogarithm,
-    algebraicPower
+  algebraicPower,
 } = module(DistributionOperation.Constructors)
 
 let algebraicAdd = algebraicAdd(~env)
@@ -18,9 +18,7 @@ let algebraicSubtract = algebraicSubtract(~env)
 let algebraicLogarithm = algebraicLogarithm(~env)
 let algebraicPower = algebraicPower(~env)
 
-
 describe("Mean", () => {
-
   let mean = GenericDist_Types.Constructors.UsingDists.mean
 
   let runMean: result<DistributionTypes.genericDist, DistributionTypes.error> => float = distR => {
@@ -30,7 +28,8 @@ describe("Mean", () => {
     }
   }
 
-    let impossiblePath: string => assertion = algebraicOp => `${algebraicOp} has`->expect->toEqual("failed")
+  let impossiblePath: string => assertion = algebraicOp =>
+    `${algebraicOp} has`->expect->toEqual("failed")
 
   let distributions = list{
     normalMake(0.0, 1e0),
@@ -40,7 +39,7 @@ describe("Mean", () => {
     // cauchyMake(1e0, 1e0),
     lognormalMake(1e0, 1e0),
     triangularMake(1e0, 1e1, 5e1),
-        Ok(floatMake(1e1))
+    Ok(floatMake(1e1)),
   }
   let combinations = E.L.combinations2(distributions)
   let zipDistsDists = E.L.zip(distributions, distributions)
@@ -53,17 +52,18 @@ describe("Mean", () => {
       let dist1 = E.R.fmap2(s => DistributionTypes.Other(s), dist1')
       let dist2 = E.R.fmap2(s => DistributionTypes.Other(s), dist2')
 
-            let received = E.R.liftJoin2(algebraicAdd, dist1, dist2) 
-                -> E.R2.fmap(mean) 
-                -> E.R2.fmap(run) 
-                -> E.R2.fmap(toFloat)
+      let received =
+        E.R.liftJoin2(algebraicAdd, dist1, dist2)
+        ->E.R2.fmap(mean)
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
       let expected = runMean(dist1) +. runMean(dist2)
       switch received {
       | Error(err) => impossiblePath("algebraicAdd")
       | Ok(x) =>
         switch x {
         | None => impossiblePath("algebraicAdd")
-                      | Some(x) => x->expect->toBeSoCloseTo(expected, ~digits=digits)
+        | Some(x) => x->expect->toBeSoCloseTo(expected, ~digits)
         }
       }
     }
@@ -91,17 +91,18 @@ describe("Mean", () => {
       let dist1 = E.R.fmap2(s => DistributionTypes.Other(s), dist1')
       let dist2 = E.R.fmap2(s => DistributionTypes.Other(s), dist2')
 
-            let received = E.R.liftJoin2(algebraicSubtract, dist1, dist2) 
-                -> E.R2.fmap(mean) 
-                -> E.R2.fmap(run) 
-                -> E.R2.fmap(toFloat)
+      let received =
+        E.R.liftJoin2(algebraicSubtract, dist1, dist2)
+        ->E.R2.fmap(mean)
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
       let expected = runMean(dist1) -. runMean(dist2)
       switch received {
       | Error(err) => impossiblePath("algebraicSubtract")
       | Ok(x) =>
         switch x {
         | None => impossiblePath("algebraicSubtract")
-                      | Some(x) => x->expect->toBeSoCloseTo(expected, ~digits=digits)
+        | Some(x) => x->expect->toBeSoCloseTo(expected, ~digits)
         }
       }
     }
@@ -120,7 +121,6 @@ describe("Mean", () => {
       let (dist1, dist2) = dists
       testSubtractionMean(dist2, dist1)
     })
-
   })
 
   describe("multiplication", () => {
@@ -130,17 +130,18 @@ describe("Mean", () => {
       let dist1 = E.R.fmap2(s => DistributionTypes.Other(s), dist1')
       let dist2 = E.R.fmap2(s => DistributionTypes.Other(s), dist2')
 
-            let received = E.R.liftJoin2(algebraicMultiply, dist1, dist2) 
-                -> E.R2.fmap(mean) 
-                -> E.R2.fmap(run) 
-                -> E.R2.fmap(toFloat)
+      let received =
+        E.R.liftJoin2(algebraicMultiply, dist1, dist2)
+        ->E.R2.fmap(mean)
+        ->E.R2.fmap(run)
+        ->E.R2.fmap(toFloat)
       let expected = runMean(dist1) *. runMean(dist2)
       switch received {
       | Error(err) => impossiblePath("algebraicMultiply")
       | Ok(x) =>
         switch x {
         | None => impossiblePath("algebraicMultiply")
-                      | Some(x) => x->expect->toBeSoCloseTo(expected, ~digits=digits)
+        | Some(x) => x->expect->toBeSoCloseTo(expected, ~digits)
         }
       }
     }
@@ -159,6 +160,5 @@ describe("Mean", () => {
       let (dist1, dist2) = dists
       testMultiplicationMean(dist2, dist1)
     })
-
   })
 })

packages/squiggle-lang/__tests__/TestHelpers.res

@@ -19,10 +19,12 @@ let run = DistributionOperation.run(~env)
 let outputMap = fmap(~env)
 let unreachableInTestFileMessage = "Should be impossible to reach (This error is in test file)"
 let toExtFloat: option<float> => float = E.O.toExt(unreachableInTestFileMessage)
-let toExtDist: option<DistributionTypes.genericDist> => DistributionTypes.genericDist = E.O.toExt(unreachableInTestFileMessage)
+let toExtDist: option<DistributionTypes.genericDist> => DistributionTypes.genericDist = E.O.toExt(
+  unreachableInTestFileMessage,
+)
 // let toExt: option<'a> => 'a = E.O.toExt(unreachableInTestFileMessage)
-let unpackFloat = x => x -> toFloat -> toExtFloat
-let unpackDist = y => y -> toDist -> toExtDist
+let unpackFloat = x => x->toFloat->toExtFloat
+let unpackDist = y => y->toDist->toExtDist
 
 let mkNormal = (mean, stdev) => DistributionTypes.Symbolic(#Normal({mean: mean, stdev: stdev}))
 let mkBeta = (alpha, beta) => DistributionTypes.Symbolic(#Beta({alpha: alpha, beta: beta}))

packages/squiggle-lang/__tests__/Utility_test.res

@@ -3,8 +3,8 @@ open Expect
 
 describe("E.L.combinations2", () => {
   test("size three", () => {
-        E.L.combinations2(list{"alice", "bob", "eve"}) -> expect -> toEqual(
-            list{("alice", "bob"), ("alice", "eve"), ("bob", "eve")}
-        )
+    E.L.combinations2(list{"alice", "bob", "eve"})
+    ->expect
+    ->toEqual(list{("alice", "bob"), ("alice", "eve"), ("bob", "eve")})
   })
 })

packages/squiggle-lang/src/rescript/Utility/E.res

@@ -180,7 +180,8 @@ module R = {
     errorCondition(r) ? Error(errorMessage) : Ok(r)
 
   let ap = Rationale.Result.ap
-  let ap' = (r, a) => switch r {
+  let ap' = (r, a) =>
+    switch r {
     | Ok(f) => fmap(f, a)
     | Error(err) => Error(err)
     }
@@ -189,11 +190,16 @@ module R = {
     ap'(fmap(op, xR), yR)
   }
 
-  let liftJoin2: (('a, 'b) => result<'c, 'd>, result<'a, 'd>, result<'b, 'd>) => result<'c, 'd> = (op, xR, yR) => {
+  let liftJoin2: (('a, 'b) => result<'c, 'd>, result<'a, 'd>, result<'b, 'd>) => result<'c, 'd> = (
+    op,
+    xR,
+    yR,
+  ) => {
     bind(liftM2(op, xR, yR), x => x)
   }
 
-  let fmap2 = (f, r) => switch r {
+  let fmap2 = (f, r) =>
+    switch r {
     | Ok(r) => r->Ok
     | Error(x) => x->f->Error
     }