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,7 +36,6 @@ let algebraicLogarithm = algebraicLogarithm(~env)
 let algebraicPower = algebraicPower(~env)
 
 describe("(Algebraic) addition of distributions", () => {
-
   describe("mean", () => {
     test("normal(mean=5) + normal(mean=20)", () => {
       normalDist5
@@ -52,7 +51,8 @@ describe("(Algebraic) addition of distributions", () => {
     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 
+      let received =
+        uniformDist
         ->algebraicAdd(betaDist)
         ->E.R2.fmap(GenericDist_Types.Constructors.UsingDists.mean)
         ->E.R2.fmap(run)
@@ -68,7 +68,8 @@ describe("(Algebraic) addition of distributions", () => {
     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 
+      let received =
+        betaDist
         ->algebraicAdd(uniformDist)
         ->E.R2.fmap(GenericDist_Types.Constructors.UsingDists.mean)
         ->E.R2.fmap(run)
@@ -84,15 +85,20 @@ describe("(Algebraic) addition of distributions", () => {
   })
   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 => {
+    testAll(
-            let received = normalDist10  // this should be normal(10, sqrt(8))
+      "(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
+        let calculated =
+          normalDist5
           ->algebraicAdd(normalDist5)
           ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, x))
           ->E.R2.fmap(run)
@@ -101,22 +107,29 @@ describe("(Algebraic) addition of distributions", () => {
           ->E.O.flatten
 
         switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
+        | None =>
-                | Some(x) => switch calculated {
+          "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
+      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
+      let calculated =
+        normalDist10
         ->algebraicAdd(normalDist10)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1.9e1))
         ->E.R2.fmap(run)
@@ -124,15 +137,20 @@ describe("(Algebraic) addition of distributions", () => {
         ->E.R.toOption
         ->E.O.flatten
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
+      | None =>
-                | Some(x) => switch calculated {
+        "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 
+      let received =
+        uniformDist
         ->algebraicAdd(betaDist)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1e1))
         ->E.R2.fmap(run)
@@ -146,7 +164,8 @@ describe("(Algebraic) addition of distributions", () => {
       }
     })
     test("(beta(alpha=2, beta=5) + uniform(low=9, high=10)).pdf(10)", () => {
-            let received = betaDist 
+      let received =
+        betaDist
         ->algebraicAdd(uniformDist)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.pdf(d, 1e1))
         ->E.R2.fmap(run)
@@ -162,14 +181,16 @@ describe("(Algebraic) addition of distributions", () => {
   })
   describe("cdf", () => {
     testAll("(normal(mean=5) + normal(mean=5)).cdf (imprecise)", list{6e0, 8e0, 1e1, 1.2e1}, x => {
-            let received = normalDist10
+      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
+      let calculated =
+        normalDist5
         ->algebraicAdd(normalDist5)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, x))
         ->E.R2.fmap(run)
@@ -178,22 +199,28 @@ describe("(Algebraic) addition of distributions", () => {
         ->E.O.flatten
 
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
+      | None =>
-                | Some(x) => switch calculated {
+        "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
+      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
+      let calculated =
+        normalDist10
         ->algebraicAdd(normalDist10)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1.25e1))
         ->E.R2.fmap(run)
@@ -201,15 +228,20 @@ describe("(Algebraic) addition of distributions", () => {
         ->E.R.toOption
         ->E.O.flatten
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
+      | None =>
-                | Some(x) => switch calculated {
+        "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 
+      let received =
+        uniformDist
         ->algebraicAdd(betaDist)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1e1))
         ->E.R2.fmap(run)
@@ -223,7 +255,8 @@ describe("(Algebraic) addition of distributions", () => {
       }
     })
     test("(beta(alpha=2, beta=5) + uniform(low=9, high=10)).cdf(10)", () => {
-            let received = betaDist 
+      let received =
+        betaDist
         ->algebraicAdd(uniformDist)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.cdf(d, 1e1))
         ->E.R2.fmap(run)
@@ -240,14 +273,16 @@ describe("(Algebraic) addition of distributions", () => {
 
   describe("inv", () => {
     testAll("(normal(mean=5) + normal(mean=5)).inv (imprecise)", list{5e-2, 4.2e-3, 9e-3}, x => {
-            let received = normalDist10
+      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
+      let calculated =
+        normalDist5
         ->algebraicAdd(normalDist5)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, x))
         ->E.R2.fmap(run)
@@ -256,22 +291,28 @@ describe("(Algebraic) addition of distributions", () => {
         ->E.O.flatten
 
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
+      | None =>
-                | Some(x) => switch calculated {
+        "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
+      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
+      let calculated =
+        normalDist10
         ->algebraicAdd(normalDist10)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 1e-1))
         ->E.R2.fmap(run)
@@ -279,15 +320,20 @@ describe("(Algebraic) addition of distributions", () => {
         ->E.R.toOption
         ->E.O.flatten
       switch received {
-                | None => "this branch occurs when the dispatch to Jstat on trusted input fails." -> expect -> toBe("never")
+      | None =>
-                | Some(x) => switch calculated {
+        "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 
+      let received =
+        uniformDist
         ->algebraicAdd(betaDist)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 2e-2))
         ->E.R2.fmap(run)
@@ -301,7 +347,8 @@ describe("(Algebraic) addition of distributions", () => {
       }
     })
     test("(beta(alpha=2, beta=5) + uniform(low=9, high=10)).inv(2e-2)", () => {
-            let received = betaDist 
+      let received =
+        betaDist
         ->algebraicAdd(uniformDist)
         ->E.R2.fmap(d => GenericDist_Types.Constructors.UsingDists.inv(d, 2e-2))
         ->E.R2.fmap(run)

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,7 +52,8 @@ 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) 
+      let received =
+        E.R.liftJoin2(algebraicAdd, dist1, dist2)
         ->E.R2.fmap(mean)
         ->E.R2.fmap(run)
         ->E.R2.fmap(toFloat)
@@ -63,7 +63,7 @@ describe("Mean", () => {
       | Ok(x) =>
         switch x {
         | None => impossiblePath("algebraicAdd")
-                      | Some(x) => x->expect->toBeSoCloseTo(expected, ~digits=digits)
+        | Some(x) => x->expect->toBeSoCloseTo(expected, ~digits)
         }
       }
     }
@@ -91,7 +91,8 @@ 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) 
+      let received =
+        E.R.liftJoin2(algebraicSubtract, dist1, dist2)
         ->E.R2.fmap(mean)
         ->E.R2.fmap(run)
         ->E.R2.fmap(toFloat)
@@ -101,7 +102,7 @@ describe("Mean", () => {
       | 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,7 +130,8 @@ 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) 
+      let received =
+        E.R.liftJoin2(algebraicMultiply, dist1, dist2)
         ->E.R2.fmap(mean)
         ->E.R2.fmap(run)
         ->E.R2.fmap(toFloat)
@@ -140,7 +141,7 @@ describe("Mean", () => {
       | 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,7 +19,9 @@ 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

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(
+    E.L.combinations2(list{"alice", "bob", "eve"})
-            list{("alice", "bob"), ("alice", "eve"), ("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
     }