diff --git a/packages/squiggle-lang/__tests__/Reducer/Reducer_Type/Reducer_Type_switch_replacement_test.res b/packages/squiggle-lang/__tests__/Reducer/Reducer_Type/Reducer_Type_switch_replacement_test.res index 16f0f118..9dbe08c5 100644 --- a/packages/squiggle-lang/__tests__/Reducer/Reducer_Type/Reducer_Type_switch_replacement_test.res +++ b/packages/squiggle-lang/__tests__/Reducer/Reducer_Type/Reducer_Type_switch_replacement_test.res @@ -4,8 +4,11 @@ open Expect module DispatchT = Reducer_Dispatch_T module Expression = Reducer_Expression module ExpressionT = Reducer_Expression_T -module TypeCompile = Reducer_Type_Compile +module ProjectAccessorsT = ReducerProject_ProjectAccessors_T +module ProjectReducerFnT = ReducerProject_ReducerFn_T module TypeChecker = Reducer_Type_TypeChecker +module TypeCompile = Reducer_Type_Compile + open ReducerInterface_InternalExpressionValue type errorValue = Reducer_ErrorValue.errorValue @@ -14,13 +17,14 @@ type errorValue = Reducer_ErrorValue.errorValue // In dispatchChainPiece, we execute an return the result of execution if there is a type match. // Otherwise we return None so that the call chain can continue. // So we want to build a function like -// dispatchChainPiece = (call: functionCall, environment): option> +// dispatchChainPiece = (call: functionCall, accessors): option> +// Use accessors.environment to get the environment finally. // Now lets make the dispatchChainPiece itself. // Note that I am not passing the reducer to the dispatchChainPiece as an argument because it is in the context anyway. // Keep in mind that reducerFn is necessary for map/reduce so dispatchChainPiece should have a reducerFn in context. -let makeMyDispatchChainPiece = (reducer: ExpressionT.reducerFn): DispatchT.dispatchChainPiece => { +let makeMyDispatchChainPiece = (reducer: ProjectReducerFnT.t): DispatchT.dispatchChainPiece => { // Let's have a pure implementations module Implementation = { let stringConcat = (a: string, b: string): string => Js.String2.concat(a, b) @@ -45,15 +49,15 @@ let makeMyDispatchChainPiece = (reducer: ExpressionT.reducerFn): DispatchT.dispa // Let's bridge the pure implementation to expression values module Bridge = { - let stringConcat: DispatchT.genericIEvFunction = (args, _environment) => { + let stringConcat: DispatchT.genericIEvFunction = (args, _accessors: ProjectAccessorsT.t) => { let (a, b) = extractStringString(args) Implementation.stringConcat(a, b)->IEvString->Ok } - let arrayConcat: DispatchT.genericIEvFunction = (args, _environment) => { + let arrayConcat: DispatchT.genericIEvFunction = (args, _accessors: ProjectAccessorsT.t) => { let (a, b) = extractArrayArray(args) Implementation.arrayConcat(a, b)->IEvArray->Ok } - let plot: DispatchT.genericIEvFunction = (args, _environment) => { + let plot: DispatchT.genericIEvFunction = (args, _accessors: ProjectAccessorsT.t) => { switch args { // Just assume that we are doing the business of extracting and converting the deep record | [IEvRecord(_)] => Implementation.plot({"title": "This is a plot"})->IEvString->Ok @@ -98,12 +102,12 @@ let makeMyDispatchChainPiece = (reducer: ExpressionT.reducerFn): DispatchT.dispa // Exactly the same as the one used in real life let _dispatch = ( call: functionCall, - environment, - reducer: Reducer_Expression_T.reducerFn, + accessors: ProjectAccessorsT.t, + reducer: ProjectReducerFnT.t, chain, ): result => { let dispatchChainPiece = makeMyDispatchChainPiece(reducer) - dispatchChainPiece(call, environment)->E.O2.defaultFn(() => chain(call, environment, reducer)) + dispatchChainPiece(call, accessors)->E.O2.defaultFn(() => chain(call, accessors, reducer)) } // What is important about this implementation? @@ -112,12 +116,12 @@ let _dispatch = ( // B) Complicated recursive record types are not a problem. describe("Type Dispatch", () => { - let reducerFn = Expression.reduceExpression + let reducerFn = Expression.reduceExpressionInProject let dispatchChainPiece = makeMyDispatchChainPiece(reducerFn) test("stringConcat", () => { let call: functionCall = ("concat", [IEvString("hello"), IEvString("world")]) - let result = dispatchChainPiece(call, defaultEnvironment) + let result = dispatchChainPiece(call, ProjectAccessorsT.identityAccessors) expect(result)->toEqual(Some(Ok(IEvString("helloworld")))) }) }) diff --git a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_ChainPiece.res b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_ChainPiece.res index 6cebfef5..310f4879 100644 --- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_ChainPiece.res +++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_ChainPiece.res @@ -1,17 +1,21 @@ -module TypeChecker = Reducer_Type_TypeChecker +module ProjectAccessorsT = ReducerProject_ProjectAccessors_T module T = Reducer_Dispatch_T +module TypeChecker = Reducer_Type_TypeChecker open ReducerInterface_InternalExpressionValue type errorValue = Reducer_ErrorValue.errorValue let makeFromTypes = jumpTable => { - let dispatchChainPiece: T.dispatchChainPiece = ((fnName, fnArgs): functionCall, environment) => { + let dispatchChainPiece: T.dispatchChainPiece = ( + (fnName, fnArgs): functionCall, + accessors: ProjectAccessorsT.t, + ) => { let jumpTableEntry = jumpTable->Js.Array2.find(elem => { let (candidName, candidType, _) = elem candidName == fnName && TypeChecker.checkITypeArgumentsBool(candidType, fnArgs) }) switch jumpTableEntry { - | Some((_, _, bridgeFn)) => bridgeFn(fnArgs, environment)->Some + | Some((_, _, bridgeFn)) => bridgeFn(fnArgs, accessors)->Some | _ => None } } diff --git a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_T.res b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_T.res index f6234976..68b8f789 100644 --- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_T.res +++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Dispatch/Reducer_Dispatch_T.res @@ -1,20 +1,22 @@ module InternalExpressionValue = ReducerInterface_InternalExpressionValue module ExpressionT = Reducer_Expression_T +module ProjectAccessorsT = ReducerProject_ProjectAccessors_T +module ProjectReducerFnT = ReducerProject_ReducerFn_T // Each piece of the dispatch chain computes the result or returns None so that the chain can continue type dispatchChainPiece = ( InternalExpressionValue.functionCall, - InternalExpressionValue.environment, + ProjectAccessorsT.t, ) => option> type dispatchChainPieceWithReducer = ( InternalExpressionValue.functionCall, - InternalExpressionValue.environment, - ExpressionT.reducerFn, + ProjectAccessorsT.t, + ProjectReducerFnT.t, ) => option> // This is a switch statement case implementation: get the arguments and compute the result type genericIEvFunction = ( array, - InternalExpressionValue.environment, + ProjectAccessorsT.t, ) => result diff --git a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Type/Reducer_Type_Compile.res b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Type/Reducer_Type_Compile.res index 25c6c0ee..b091782c 100644 --- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Type/Reducer_Type_Compile.res +++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Type/Reducer_Type_Compile.res @@ -38,7 +38,7 @@ let fromTypeExpression = (typeExpressionSourceCode: string, reducerFn: ProjectRe let fromTypeExpressionExn = ( typeExpressionSourceCode: string, - reducerFn: ExpressionT.reducerFn, + reducerFn: ProjectReducerFnT.t, ): T.t => switch fromTypeExpression(typeExpressionSourceCode, reducerFn) { | Ok(value) => value