ran rescript format on ProgramEvaluator.res

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

@@ -39,17 +39,16 @@ module Inputs = {
 type exportDistribution = [
   | #DistPlus(DistPlus.t)
   | #Float(float)
-  | #Function((float) => Belt.Result.t<DistPlus.t,string>)
+  | #Function(float => Belt.Result.t<DistPlus.t, string>)
 ]
 
 type exportEnv = array<(string, ASTTypes.node)>
 
 type exportType = {
-  environment : exportEnv,
+  environment: exportEnv,
-  exports: array<exportDistribution>
+  exports: array<exportDistribution>,
 }
 
-
 module Internals = {
   let addVariable = (
     {samplingInputs, squiggleString, environment}: Inputs.inputs,
@@ -58,9 +57,7 @@ module Internals = {
   ): Inputs.inputs => {
     samplingInputs: samplingInputs,
     squiggleString: squiggleString,
-    environment: ASTTypes.Environment.update(environment, str, _ => Some(
+    environment: ASTTypes.Environment.update(environment, str, _ => Some(node)),
-      node,
-    )),
   }
 
   type outputs = {
@@ -76,8 +73,7 @@ module Internals = {
     pointSetDistLength: inputs.samplingInputs.pointDistLength |> E.O.default(10000),
   }
 
-  let runNode = (inputs, node) =>
+  let runNode = (inputs, node) => AST.toLeaf(makeInputs(inputs), inputs.environment, node)
-    AST.toLeaf(makeInputs(inputs), inputs.environment, node)
 
   let renderIfNeeded = (inputs: Inputs.inputs, node: ASTTypes.node): result<
     ASTTypes.node,
@@ -106,16 +102,14 @@ module Internals = {
   let outputToDistPlus = (inputs: Inputs.inputs, pointSetDist: PointSetTypes.pointSetDist) =>
     DistPlus.make(~pointSetDist, ~squiggleString=Some(inputs.squiggleString), ())
 
-  let rec returnDist = (functionInfo : (array<string>, ASTTypes.node), 
+  let rec returnDist = (
-                    inputs : Inputs.inputs,
+    functionInfo: (array<string>, ASTTypes.node),
-                    env : ASTTypes.environment) => {
+    inputs: Inputs.inputs,
-    (input : float) => {
+    env: ASTTypes.environment,
-      let foo: Inputs.inputs = {...inputs, environment: env};
+  ) => {
-      evaluateFunction(
+    (input: float) => {
-        foo,
+      let foo: Inputs.inputs = {...inputs, environment: env}
-        functionInfo,
+      evaluateFunction(foo, functionInfo, [#SymbolicDist(#Float(input))]) |> E.R.bind(_, a =>
-        [#SymbolicDist(#Float(input))],
-      ) |> E.R.bind(_, a =>
         switch a {
         | #DistPlus(d) => Ok(DistPlus.T.normalize(d))
         | n =>
@@ -126,11 +120,10 @@ module Internals = {
     }
   }
   // TODO: Consider using ExpressionTypes.ExpressionTree.getFloat or similar in this function
-  and coersionToExportedTypes = (
+  and coersionToExportedTypes = (inputs, env: ASTTypes.environment, ex: ASTTypes.node): result<
-    inputs,
+    exportDistribution,
-    env: ASTTypes.environment,
+    string,
-    ex: ASTTypes.node,
+  > =>
-  ): result<exportDistribution, string> =>
     ex
     |> renderIfNeeded(inputs)
     |> E.R.bind(_, x =>
@@ -143,17 +136,8 @@ module Internals = {
       }
     )
 
-  and evaluateFunction = (
+  and evaluateFunction = (inputs: Inputs.inputs, fn: (array<string>, ASTTypes.node), fnInputs) => {
-    inputs: Inputs.inputs,
+    let output = AST.runFunction(makeInputs(inputs), inputs.environment, fnInputs, fn)
-    fn: (array<string>, ASTTypes.node),
-    fnInputs,
-  ) => {
-    let output = AST.runFunction(
-      makeInputs(inputs),
-      inputs.environment,
-      fnInputs,
-      fn,
-    )
     output |> E.R.bind(_, coersionToExportedTypes(inputs, inputs.environment))
   }
 
@@ -165,8 +149,7 @@ module Internals = {
       | #Assignment(name, node) =>
         ins := addVariable(ins.contents, name, node)
         None
-        | #Expression(node) =>
+      | #Expression(node) => Some(runNode(ins.contents, node))
-          Some(runNode(ins.contents, node))
       }
     )
     |> E.A.O.concatSomes
@@ -176,23 +159,22 @@ module Internals = {
       |> E.A.fmap(x => coersionToExportedTypes(inputs, ins.contents.environment, x))
       |> E.A.R.firstErrorOrOpen
     )
-      |> E.R.fmap(ex => 
+    |> E.R.fmap(ex => {
-          {
       environment: Belt.Map.String.toArray(ins.contents.environment),
-            exports: ex
+      exports: ex,
-          }
+    })
-        )
   }
 
   let inputsToLeaf = (inputs: Inputs.inputs) =>
     Parser.fromString(inputs.squiggleString) |> E.R.bind(_, g => runProgram(inputs, g))
-
 }
 
-
 @genType
-let runAll : (string, Inputs.SamplingInputs.t, exportEnv) => result<exportType,string> = 
+let runAll: (string, Inputs.SamplingInputs.t, exportEnv) => result<exportType, string> = (
-   (squiggleString, samplingInputs, environment) => {
+  squiggleString,
+  samplingInputs,
+  environment,
+) => {
   let inputs = Inputs.make(
     ~samplingInputs,
     ~squiggleString,