bindings and module managers

bindings are a module

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

@@ -2,77 +2,25 @@ module ErrorValue = Reducer_ErrorValue
 module ExpressionT = Reducer_Expression_T
 module ExpressionValue = ReducerInterface.ExpressionValue
 module Result = Belt.Result
+module BindingsManager = Reducer_Manager_Bindings
 
 type errorValue = Reducer_ErrorValue.errorValue
 type expression = ExpressionT.expression
 type expressionValue = ExpressionValue.expressionValue
 type externalBindings = ReducerInterface_ExpressionValue.externalBindings
 
-let defaultBindings: ExpressionT.bindings = Belt.Map.String.empty
+let emptyBindings = Reducer_Manager_Bindings.emptyBindings
 
-let typeAliasesKey = "_typeAliases_"
+let typeAliasesKey = BindingsManager.typeAliasesKey
-let typeReferencesKey = "_typeReferences_"
+let typeReferencesKey = BindingsManager.typeReferencesKey
 
-let toExternalBindings = (bindings: ExpressionT.bindings): externalBindings => {
+let toExternalBindings = (bindings: ExpressionT.bindings): externalBindings =>
-  let keys = Belt.Map.String.keysToArray(bindings)
+  BindingsManager.toRecord(bindings)
-  keys->Belt.Array.reduce(Js.Dict.empty(), (acc, key) => {
-    let value = bindings->Belt.Map.String.getExn(key)
-    Js.Dict.set(acc, key, value)
-    acc
-  })
-}
 
-let fromExternalBindings_ = (externalBindings: externalBindings): ExpressionT.bindings => {
+let fromExternalBindings = (externalBindings: externalBindings): ExpressionT.bindings =>
-  let keys = Js.Dict.keys(externalBindings)
+  BindingsManager.fromRecord(externalBindings)
-  keys->Belt.Array.reduce(defaultBindings, (acc, key) => {
-    let value = Js.Dict.unsafeGet(externalBindings, key)
-    acc->Belt.Map.String.set(key, value)
-  })
-}
 
-let fromExternalBindings = (externalBindings: externalBindings): ExpressionT.bindings => {
+let fromValue = (aValue: expressionValue) => BindingsManager.fromExpressionValue(aValue)
-  // TODO: This code will be removed in the future when maps are used instead of records. Please don't mind this function for now.
-
-  let internalBindings0 = fromExternalBindings_(externalBindings)
-
-  let oExistingTypeAliases = Belt.Map.String.get(internalBindings0, typeAliasesKey)
-  let internalBindings1 = Belt.Option.mapWithDefault(
-    oExistingTypeAliases,
-    internalBindings0,
-    existingTypeAliases => {
-      let newTypeAliases = switch existingTypeAliases {
-      | EvRecord(actualTypeAliases) =>
-        actualTypeAliases->fromExternalBindings_->toExternalBindings->ExpressionValue.EvRecord
-      | _ => existingTypeAliases
-      }
-      Belt.Map.String.set(internalBindings0, typeAliasesKey, newTypeAliases)
-    },
-  )
-
-  let oExistingTypeReferences = Belt.Map.String.get(internalBindings1, typeReferencesKey)
-  let internalBindings2 = Belt.Option.mapWithDefault(
-    oExistingTypeReferences,
-    internalBindings1,
-    existingTypeReferences => {
-      let newTypeReferences = switch existingTypeReferences {
-      | EvRecord(actualTypeReferences) =>
-        actualTypeReferences->fromExternalBindings_->toExternalBindings->ExpressionValue.EvRecord
-      | _ => existingTypeReferences
-      }
-      Belt.Map.String.set(internalBindings0, typeReferencesKey, newTypeReferences)
-    },
-  )
-
-  internalBindings2
-}
-
-let fromValue = (aValue: expressionValue) =>
-  switch aValue {
-  | EvRecord(externalBindings) => fromExternalBindings(externalBindings)
-  | _ => defaultBindings
-  }
-
-let externalFromArray = anArray => Js.Dict.fromArray(anArray)
 
 let isMacroName = (fName: string): bool => fName->Js.String2.startsWith("$$")
 

packages/squiggle-lang/src/rescript/Reducer/Reducer_Manager/Reducer_Manager_Bindings.res

@@ -0,0 +1,12 @@
+include Reducer_Manager_Module
+
+open ReducerInterface_ExpressionValue
+
+let emptyBindings = emptyModule
+
+let toExpressionValue = (container: t): expressionValue => EvRecord(toRecord(container))
+let fromExpressionValue = (aValue: expressionValue): t =>
+  switch aValue {
+  | EvRecord(r) => fromRecord(r)
+  | _ => emptyBindings
+  }

packages/squiggle-lang/src/rescript/Reducer/Reducer_Manager/Reducer_Manager_Module.res

@@ -0,0 +1,29 @@
+module ExpressionT = Reducer_Expression_T
+open ReducerInterface_ExpressionValue
+let expressionValueToString = toString
+
+type t = ExpressionT.bindings
+
+let typeAliasesKey = "_typeAliases_"
+let typeReferencesKey = "_typeReferences_"
+
+let define = (container: t, identifier: string, ev: expressionValue): t =>
+  Belt.Map.String.set(container, identifier, ev) // TODO build lambda for polymorphic functions here
+
+let defineNumber = (container: t, identifier: string, value: float): t =>
+  container->define(identifier, EvNumber(value))
+
+let cloneRecord = (r: record): record => r->Js.Dict.entries->Js.Dict.fromArray
+let fromRecord = (r: record): t => Js.Dict.entries(r)->Belt.Map.String.fromArray
+let toRecord = (container: t): record => Belt.Map.String.toArray(container)->Js.Dict.fromArray
+
+let emptyModule: t = Belt.Map.String.empty
+
+let toExpressionValue = (container: t): expressionValue => EvModule(toRecord(container))
+let fromExpressionValue = (aValue: expressionValue): t =>
+  switch aValue {
+  | EvModule(r) => fromRecord(r)
+  | _ => emptyModule
+  }
+
+let toString = (container: t): string => container->toRecord->EvRecord->expressionValueToString

packages/squiggle-lang/src/rescript/SquiggleLibrary/SquiggleLibrary_DefaultBindings.res

@@ -0,0 +1 @@
+

packages/squiggle-lang/src/rescript/SquiggleLibrary/SquiggleLibrary_Math.res

@@ -0,0 +1 @@
+