Format rescript

packages/squiggle-lang/__tests__/SquiggleLibrary/SquiggleLibrary_FunctionRegistryLibrary_test.res

@@ -82,7 +82,10 @@ describe("FunctionRegistry Library", () => {
     )
 
     testEvalToBe("Dict.merge({a: 1, b: 2}, {b: 3, c: 4, d: 5})", "Ok({a: 1,b: 3,c: 4,d: 5})")
-    testEvalToBe("Dict.mergeMany([{a: 1, b: 2}, {c: 3, d: 4}, {c: 5, e: 6}])", "Ok({a: 1,b: 2,c: 5,d: 4,e: 6})")
+    testEvalToBe(
+      "Dict.mergeMany([{a: 1, b: 2}, {c: 3, d: 4}, {c: 5, e: 6}])",
+      "Ok({a: 1,b: 2,c: 5,d: 4,e: 6})",
+    )
     testEvalToBe("Dict.keys({a: 1, b: 2})", "Ok(['a','b'])")
     testEvalToBe("Dict.values({a: 1, b: 2})", "Ok([1,2])")
     testEvalToBe("Dict.toList({a: 1, b: 2})", "Ok([['a',1],['b',2]])")

packages/squiggle-lang/src/rescript/FR/FR_Dict.res

@@ -59,7 +59,6 @@ let library = [
     ],
     (),
   ),
-
   Function.make(
     ~name="mergeMany",
     ~nameSpace,
@@ -72,13 +71,16 @@ let library = [
         ~inputs=[FRTypeArray(FRTypeDict(FRTypeAny))],
         ~run=(inputs, _, _) => {
           switch inputs {
-            | [IEvArray(dicts)] => {
+          | [IEvArray(dicts)] => dicts
-              dicts->Belt.Array.map(dictValue => switch dictValue {
+            ->Belt.Array.map(dictValue =>
-                | IEvRecord(dict) => dict
+              switch dictValue {
-                | _ => impossibleError->Reducer_ErrorValue.toException
+              | IEvRecord(dict) => dict
-              })->Internals.mergeMany->Ok
+              | _ => impossibleError->Reducer_ErrorValue.toException
-            }
+              }
-            | _ => impossibleError->Error
+            )
+            ->Internals.mergeMany
+            ->Ok
+          | _ => impossibleError->Error
           }
         },
         (),

packages/squiggle-lang/src/rescript/FR/FR_Dist.res

@@ -22,8 +22,7 @@ module DistributionCreation = {
       FnDefinition.make(
         ~name,
         ~inputs=[FRTypeDistOrNumber, FRTypeDistOrNumber],
-        ~run=(inputs, env, _) =>
+        ~run=(inputs, env, _) => inputs->Prepare.ToValueTuple.twoDistOrNumber->process(~fn, ~env),
-          inputs->Prepare.ToValueTuple.twoDistOrNumber->process(~fn, ~env),
         (),
       )
     }
@@ -43,7 +42,9 @@ module DistributionCreation = {
         ~name,
         ~inputs=[FRTypeRecord([("mean", FRTypeDistOrNumber), ("stdev", FRTypeDistOrNumber)])],
         ~run=(inputs, env, _) =>
-          inputs->Prepare.ToValueTuple.Record.twoDistOrNumber(("mean", "stdev"))->process(~fn, ~env),
+          inputs
+          ->Prepare.ToValueTuple.Record.twoDistOrNumber(("mean", "stdev"))
+          ->process(~fn, ~env),
         (),
       )
     }
@@ -60,8 +61,7 @@ module DistributionCreation = {
       FnDefinition.make(
         ~name,
         ~inputs=[FRTypeDistOrNumber],
-        ~run=(inputs, env, _) =>
+        ~run=(inputs, env, _) => inputs->Prepare.ToValueTuple.oneDistOrNumber->process(~fn, ~env),
-          inputs->Prepare.ToValueTuple.oneDistOrNumber->process(~fn, ~env),
         (),
       )
   }

packages/squiggle-lang/src/rescript/FR/FR_List.res

@@ -109,8 +109,8 @@ let library = [
         ~inputs=[FRTypeNumber, FRTypeNumber],
         ~run=(inputs, _, _) =>
           switch inputs {
-            | [IEvNumber(low), IEvNumber(high)] => Internals.upTo(low, high)->Ok
+          | [IEvNumber(low), IEvNumber(high)] => Internals.upTo(low, high)->Ok
-            | _ => impossibleError->Error
+          | _ => impossibleError->Error
           },
         (),
       ),

packages/squiggle-lang/src/rescript/FR/FR_Pointset.res

@@ -7,24 +7,24 @@ let requiresNamespace = true
 let inputsToDist = (inputs: array<Reducer_T.value>, xyShapeToPointSetDist) => {
   // TODO - rewrite in more functional/functor-based style
   switch inputs {
-    | [IEvArray(items)] => {
+  | [IEvArray(items)] => items
-      items->Belt.Array.map(
+    ->Belt.Array.map(item =>
-        item =>
+      switch item {
-        switch item {
+      | IEvRecord(map) => {
-          | IEvRecord(map) => {
+          let xValue = map->Belt.Map.String.get("x")
-            let xValue = map->Belt.Map.String.get("x")
+          let yValue = map->Belt.Map.String.get("y")
-            let yValue = map->Belt.Map.String.get("y")
+          switch (xValue, yValue) {
-            switch (xValue, yValue) {
+          | (Some(IEvNumber(x)), Some(IEvNumber(y))) => (x, y)
-            | (Some(IEvNumber(x)), Some(IEvNumber(y))) => (x, y)
-            | _ => impossibleError->Reducer_ErrorValue.toException
-            }
-          }
           | _ => impossibleError->Reducer_ErrorValue.toException
+          }
         }
-      )->Ok->E.R.bind(r => r->XYShape.T.makeFromZipped->E.R2.errMap(XYShape.Error.toString))
+      | _ => impossibleError->Reducer_ErrorValue.toException
-       ->E.R2.fmap(r => Reducer_T.IEvDistribution(PointSet(r->xyShapeToPointSetDist)))
+      }
-    }
+    )
-    | _ => impossibleError->Reducer_ErrorValue.toException
+    ->Ok
+    ->E.R.bind(r => r->XYShape.T.makeFromZipped->E.R2.errMap(XYShape.Error.toString))
+    ->E.R2.fmap(r => Reducer_T.IEvDistribution(PointSet(r->xyShapeToPointSetDist)))
+  | _ => impossibleError->Reducer_ErrorValue.toException
   }
 }
 

packages/squiggle-lang/src/rescript/FR/FR_Sampleset.res

@@ -115,9 +115,8 @@ let libaryBase = [
         ~inputs=[FRTypeArray(FRTypeNumber)],
         ~run=(inputs, _, _) => {
           let sampleSet =
-            inputs->Prepare.ToTypedArray.numbers |> E.R2.bind(r =>
+            inputs->Prepare.ToTypedArray.numbers
-              SampleSetDist.make(r)->E.R2.errMap(_ => "AM I HERE? WHYERE AMI??")
+              |> E.R2.bind(r => SampleSetDist.make(r)->E.R2.errMap(_ => "AM I HERE? WHYERE AMI??"))
-            )
           sampleSet
           ->E.R2.fmap(Wrappers.sampleSet)
           ->E.R2.fmap(Wrappers.evDistribution)

packages/squiggle-lang/src/rescript/FR/FR_Scoring.res

@@ -31,14 +31,13 @@ let library = [
           ]),
         ],
         ~run=(inputs, environment, _) => {
-          switch FunctionRegistry_Helpers.Prepare.ToValueArray.Record.threeArgs(inputs, ("estimate", "answer", "prior")) {
+          switch FunctionRegistry_Helpers.Prepare.ToValueArray.Record.threeArgs(
+            inputs,
+            ("estimate", "answer", "prior"),
+          ) {
           | Ok([IEvDistribution(estimate), IEvDistribution(d), IEvDistribution(prior)]) =>
             runScoring(estimate, Score_Dist(d), Some(prior), environment)
-          | Ok([
+          | Ok([IEvDistribution(estimate), IEvNumber(d), IEvDistribution(prior)]) =>
-              IEvDistribution(estimate),
-              IEvNumber(d),
-              IEvDistribution(prior),
-            ]) =>
             runScoring(estimate, Score_Scalar(d), Some(prior), environment)
           | Error(e) => Error(e->FunctionRegistry_Helpers.wrapError)
           | _ => Error(FunctionRegistry_Helpers.impossibleError)
@@ -50,7 +49,10 @@ let library = [
         ~name="logScore",
         ~inputs=[FRTypeRecord([("estimate", FRTypeDist), ("answer", FRTypeDistOrNumber)])],
         ~run=(inputs, environment, _) => {
-          switch FunctionRegistry_Helpers.Prepare.ToValueArray.Record.twoArgs(inputs, ("estimate", "answer")) {
+          switch FunctionRegistry_Helpers.Prepare.ToValueArray.Record.twoArgs(
+            inputs,
+            ("estimate", "answer"),
+          ) {
           | Ok([IEvDistribution(estimate), IEvDistribution(d)]) =>
             runScoring(estimate, Score_Dist(d), None, environment)
           | Ok([IEvDistribution(estimate), IEvNumber(d)]) =>

packages/squiggle-lang/src/rescript/FunctionRegistry/FunctionRegistry_Core.res

@@ -83,19 +83,20 @@ module FRType = {
     | (FRTypeNumeric, IEvNumber(_)) => true
     | (FRTypeNumeric, IEvDistribution(Symbolic(#Float(_)))) => true
     | (FRTypeLambda, IEvLambda(_)) => true
-    | (FRTypeArray(intendedType), IEvArray(elements)) => {
+    | (FRTypeArray(intendedType), IEvArray(elements)) => elements->Belt.Array.every(v =>
-        elements->Belt.Array.every(v => matchWithValue(intendedType, v))
+        matchWithValue(intendedType, v)
-      }
+      )
     | (FRTypeDict(r), IEvRecord(map)) =>
       map->Belt.Map.String.valuesToArray->Belt.Array.every(v => matchWithValue(r, v))
-    | (FRTypeRecord(recordParams), IEvRecord(map)) => {
+    | (FRTypeRecord(recordParams), IEvRecord(map)) => recordParams->Belt.Array.every(((
-      recordParams->Belt.Array.every(((name, input)) => {
+        name,
+        input,
+      )) => {
         switch map->Belt.Map.String.get(name) {
-          | Some(v) => matchWithValue(input, v)
+        | Some(v) => matchWithValue(input, v)
-          | None => false
+        | None => false
         }
       })
-    }
     | _ => false
     }
 
@@ -104,8 +105,7 @@ module FRType = {
     if !isSameLength {
       false
     } else {
-      E.A.zip(inputs, args)
+      E.A.zip(inputs, args)->Belt.Array.every(((input, arg)) => matchWithValue(input, arg))
-      ->Belt.Array.every(((input, arg)) => matchWithValue(input, arg))
     }
   }
 }

packages/squiggle-lang/src/rescript/FunctionRegistry/FunctionRegistry_Helpers.res

@@ -30,21 +30,21 @@ module Prepare = {
       let twoArgs = (inputs: ts, (arg1: string, arg2: string)): result<ts, err> =>
         switch inputs {
         | [IEvRecord(map)] => {
-          let n1 = map->Belt.Map.String.getExn(arg1)
+            let n1 = map->Belt.Map.String.getExn(arg1)
-          let n2 = map->Belt.Map.String.getExn(arg2)
+            let n2 = map->Belt.Map.String.getExn(arg2)
-          Ok([n1, n2])
+            Ok([n1, n2])
-        }
+          }
         | _ => Error(impossibleErrorString)
         }
 
       let threeArgs = (inputs: ts, (arg1: string, arg2: string, arg3: string)): result<ts, err> =>
         switch inputs {
         | [IEvRecord(map)] => {
-          let n1 = map->Belt.Map.String.getExn(arg1)
+            let n1 = map->Belt.Map.String.getExn(arg1)
-          let n2 = map->Belt.Map.String.getExn(arg2)
+            let n2 = map->Belt.Map.String.getExn(arg2)
-          let n3 = map->Belt.Map.String.getExn(arg3)
+            let n3 = map->Belt.Map.String.getExn(arg3)
-          Ok([n1, n2, n3])
+            Ok([n1, n2, n3])
-        }
+          }
         | _ => Error(impossibleErrorString)
         }
     }
@@ -108,8 +108,10 @@ module Prepare = {
     }
 
     module Record = {
-      let twoDistOrNumber = (values: ts, labels: (string, string)): result<(frValueDistOrNumber, frValueDistOrNumber), err> =>
+      let twoDistOrNumber = (values: ts, labels: (string, string)): result<
-        values->ToValueArray.Record.twoArgs(labels)->E.R.bind(twoDistOrNumber)
+        (frValueDistOrNumber, frValueDistOrNumber),
+        err,
+      > => values->ToValueArray.Record.twoArgs(labels)->E.R.bind(twoDistOrNumber)
 
       let twoDist = (values: ts, labels: (string, string)): result<
         (DistributionTypes.genericDist, DistributionTypes.genericDist),

packages/squiggle-lang/src/rescript/ReducerProject/ReducerProject.res

@@ -188,7 +188,6 @@ let linkDependencies = (project: t, sourceId: string): Reducer_T.namespace => {
     acc->Reducer_Namespace.set(
       variable,
       project->getBindings(includeFile)->Reducer_Namespace.toRecord,
-
     )
   )
 }