value vs result conversion functions

packages/squiggle-lang/__tests__/Reducer/Reducer_TestMacroHelpers.res

@@ -17,18 +17,17 @@ let testMacro_ = (
   expectedCode: string,
 ) => {
   let bindings = Bindings.fromArray(bindArray)
-  tester(expr->T.toString, () => {
+  tester(expr->T.toString, () =>
-    let result = switch expr->Reducer_Dispatch_BuiltInMacros.dispatchMacroCall(
+    expr
+    ->Macro.expandMacroCallRs(
       bindings,
       ProjectAccessorsT.identityAccessors,
       Expression.reduceExpressionInProject,
-    ) {
+    )
-    | v => Ok(v)
+    ->ExpressionWithContext.toStringResult
-    | exception Reducer_ErrorValue.ErrorException(e) => Error(e)
+    ->expect
-    }
+    ->toEqual(expectedCode)
-
+  )
-    result->ExpressionWithContext.toStringResult->expect->toEqual(expectedCode)
-  })
 }
 
 let testMacroEval_ = (

packages/squiggle-lang/__tests__/Reducer/Reducer_test.res

@@ -56,7 +56,7 @@ describe("test exceptions", () => {
   testDescriptionEvalToBe(
     "javascript exception",
     "javascriptraise('div by 0')",
-    "Error(JS Exception: Error: 'div by 0')",
+    "Error(Error: 'div by 0')",
   )
   // testDescriptionEvalToBe(
   //   "rescript exception",

packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_BuiltIn.res

@@ -3,6 +3,7 @@ module BindingsReplacer = Reducer_Expression_BindingsReplacer
 module Continuation = ReducerInterface_Value_Continuation
 module ExpressionT = Reducer_Expression_T
 module ExternalLibrary = ReducerInterface.ExternalLibrary
+module InternalExpressionValue = ReducerInterface_InternalExpressionValue
 module Lambda = Reducer_Expression_Lambda
 module MathJs = Reducer_MathJs
 module ProjectAccessorsT = ReducerProject_ProjectAccessors_T
@@ -206,13 +207,12 @@ let dispatch = (
     let (fn, args) = call
     // There is a bug that prevents string match in patterns
     // So we have to recreate a copy of the string
-    switch ExternalLibrary.dispatch((Js.String.make(fn), args), accessors, reducer, callInternal) {
+    ExternalLibrary.dispatch(
-    | Ok(v) => v
+      (Js.String.make(fn), args),
-    | Error(e) => raise(ErrorException(e))
+      accessors,
-    }
+      reducer,
+      callInternal,
+    )->InternalExpressionValue.resultToValue
   } catch {
-  | ErrorException(e) => raise(ErrorException(e))
+  | exn => Reducer_ErrorValue.fromException(exn)->Reducer_ErrorValue.toException
-  | Js.Exn.Error(obj) =>
-    raise(ErrorException(REJavaScriptExn(Js.Exn.message(obj), Js.Exn.name(obj))))
-  | _ => raise(ErrorException(RETodo("unhandled rescript exception")))
   }

packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_BuiltInMacros.res

@@ -15,7 +15,6 @@ module ProjectReducerFnT = ReducerProject_ReducerFn_T
 
 open Reducer_Expression_ExpressionBuilder
 
-exception ErrorException = ErrorValue.ErrorException
 type expression = ExpressionT.expression
 type expressionWithContext = ExpressionWithContext.expressionWithContext
 
@@ -45,7 +44,7 @@ let dispatchMacroCall = (
     }
 
   let doBindStatement = (bindingExpr: expression, statement: expression, accessors) => {
-    let defaultStatement = ErrorValue.REAssignmentExpected->ErrorException
+    let defaultStatement = ErrorValue.REAssignmentExpected
     switch statement {
     | ExpressionT.EList(list{ExpressionT.EValue(IEvCall(callName)), symbolExpr, statement}) => {
         let setBindingsFn = correspondingSetBindingsFn(callName)
@@ -55,10 +54,10 @@ let dispatchMacroCall = (
             boundStatement,
           ) => eFunction(setBindingsFn, list{newBindingsExpr, symbolExpr, boundStatement}))
         } else {
-          raise(defaultStatement)
+          defaultStatement->Reducer_ErrorValue.toException
         }
       }
-    | _ => raise(defaultStatement)
+    | _ => defaultStatement->Reducer_ErrorValue.toException
     }
   }
 
@@ -142,7 +141,7 @@ let dispatchMacroCall = (
         let ifTrueBlock = eBlock(list{ifTrue})
         ExpressionWithContext.withContext(ifTrueBlock, bindings)
       }
-    | _ => raise(ErrorException(REExpectedType("Boolean", "")))
+    | _ => REExpectedType("Boolean", "")->Reducer_ErrorValue.toException
     }
   }
 

packages/squiggle-lang/src/rescript/Reducer/Reducer_ErrorValue.res

@@ -64,3 +64,20 @@ let errorToString = err =>
   | RENeedToRun => "Need to run"
   | REOther(msg) => `Error: ${msg}`
   }
+
+let fromException = exn =>
+  switch exn {
+  | ErrorException(e) => e
+  | Js.Exn.Error(e) =>
+    switch Js.Exn.message(e) {
+    | Some(message) => REOther(message)
+    | None =>
+      switch Js.Exn.name(e) {
+      | Some(name) => REOther(name)
+      | None => REOther("Unknown error")
+      }
+    }
+  | _e => REOther("Unknown error")
+  }
+
+let toException = (errorValue: t) => raise(ErrorException(errorValue))

packages/squiggle-lang/src/rescript/Reducer/Reducer_Expression/Reducer_Expression.res

@@ -101,8 +101,7 @@ module BackCompatible = {
     try {
       expression->reduceExpressionInProject(accessors.stdLib, accessors)->Ok
     } catch {
-    | ErrorException(e) => Error(e)
+    | exn => Reducer_ErrorValue.fromException(exn)->Error
-    | _ => raise(ErrorException(RETodo("internal exception")))
     }
   }
 

packages/squiggle-lang/src/rescript/Reducer/Reducer_Expression/Reducer_ExpressionWithContext.res

@@ -18,6 +18,8 @@ type expressionWithContext =
   | ExpressionWithContext(expression, context)
   | ExpressionNoContext(expression)
 
+type t = expressionWithContext
+
 let callReducer = (
   expressionWithContext: expressionWithContext,
   bindings: bindings,
@@ -51,3 +53,10 @@ let toStringResult = rExpressionWithContext =>
   | Ok(expressionWithContext) => `Ok(${toString(expressionWithContext)})`
   | Error(errorValue) => ErrorValue.errorToString(errorValue)
   }
+
+let resultToValue = (rExpressionWithContext: result<t, errorValue>): t => {
+  switch rExpressionWithContext {
+  | Ok(expressionWithContext) => expressionWithContext
+  | Error(errorValue) => ErrorValue.toException(errorValue)
+  }
+}

packages/squiggle-lang/src/rescript/Reducer/Reducer_Expression/Reducer_Expression_BindingsReplacer.res

@@ -41,9 +41,5 @@ and checkIfCallable = (evValue: internalExpressionValue) =>
   switch evValue {
   | IEvCall(_) | IEvLambda(_) => evValue
   | _ =>
-    raise(
+    ErrorValue.RENotAFunction(InternalExpressionValue.toString(evValue))->ErrorValue.toException
-      ErrorValue.ErrorException(
-        ErrorValue.RENotAFunction(InternalExpressionValue.toString(evValue)),
-      ),
-    )
   }

packages/squiggle-lang/src/rescript/Reducer/Reducer_Expression/Reducer_Expression_Macro.res

@@ -10,6 +10,23 @@ type expression = ExpressionT.expression
 type internalExpressionValue = InternalExpressionValue.t
 type expressionWithContext = ExpressionWithContext.expressionWithContext
 
+let expandMacroCallRs = (
+  macroExpression: expression,
+  bindings: ExpressionT.bindings,
+  accessors: ProjectAccessorsT.t,
+  reduceExpression: ProjectReducerFnT.t,
+): result<expressionWithContext, 'e> =>
+  try {
+    Reducer_Dispatch_BuiltInMacros.dispatchMacroCall(
+      macroExpression,
+      bindings,
+      accessors,
+      reduceExpression,
+    )->Ok
+  } catch {
+  | exn => Reducer_ErrorValue.fromException(exn)->Error
+  }
+
 let doMacroCall = (
   macroExpression: expression,
   bindings: ExpressionT.bindings,

packages/squiggle-lang/src/rescript/Reducer/Reducer_Expression/Reducer_Expression_T.res

@@ -82,3 +82,9 @@ type optionFfiFnReturningResult = (
 type expressionOrFFI =
   | NotFFI(expression)
   | FFI(ffiFn)
+
+let resultToValue = (rExpression: result<t, Reducer_ErrorValue.t>): t =>
+  switch rExpression {
+  | Ok(expression) => expression
+  | Error(errorValue) => Reducer_ErrorValue.toException(errorValue)
+  }

packages/squiggle-lang/src/rescript/Reducer/Reducer_Type/Reducer_Type_Compile.res

@@ -15,7 +15,7 @@ let ievFromTypeExpression = (
   let sourceCode = `type ${sIndex}=${typeExpressionSourceCode}`
   Reducer_Expression.BackCompatible.parse(sourceCode)->Belt.Result.flatMap(expr => {
     let accessors = ProjectAccessorsT.identityAccessors
-    let result = reducerFn(expr, Bindings.emptyBindings, accessors)
+    let _result = reducerFn(expr, Bindings.emptyBindings, accessors)
     let nameSpace = accessors.states.continuation
 
     switch Bindings.getType(nameSpace, sIndex) {

packages/squiggle-lang/src/rescript/ReducerInterface/ReducerInterface_InternalExpressionValue.res

@@ -244,3 +244,9 @@ let nameSpaceGet = (nameSpace: nameSpace, key: string): option<t> => {
   let NameSpace(container) = nameSpace
   container->Belt.Map.String.get(key)
 }
+
+let resultToValue = (rExpression: result<t, Reducer_ErrorValue.t>): t =>
+  switch rExpression {
+  | Ok(expression) => expression
+  | Error(errorValue) => Reducer_ErrorValue.toException(errorValue)
+  }

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

@@ -195,8 +195,7 @@ let doBuildResult = (
       try {
         Reducer_Expression.reduceExpressionInProject(expression, aContinuation, accessors)->Ok
       } catch {
-      | Reducer_ErrorValue.ErrorException(e) => e->Error
+      | exn => Reducer_ErrorValue.fromException(exn)->Error
-      | _ => RETodo("unhandled rescript exception")->Error
       }
     ),
   )