Reduce usage of records for more efficiency in the Elm compiler

pine-vm · Jul 6, 2024 · e08d6da · e08d6da
1 parent 7987a15
commit e08d6da
Show file tree

Hide file tree

Showing 11 changed files with 626 additions and 682 deletions.
diff --git a/implement/pine/ElmTime/compile-elm-program/src/ElmCompiler.elm b/implement/pine/ElmTime/compile-elm-program/src/ElmCompiler.elm
diff --git a/implement/pine/ElmTime/compile-elm-program/src/ElmCompilerConstruction.elm b/implement/pine/ElmTime/compile-elm-program/src/ElmCompilerConstruction.elm
@@ -40,12 +40,12 @@ generateTemplateEvaluatingToExpression expression =
                 "Literal"
                 (Pine.LiteralExpression literal)
 
-        Pine.ParseAndEvalExpression parseAndEval ->
+        Pine.ParseAndEvalExpression envExpr exprExpr ->
             buildFromTagAndArgument
                 "ParseAndEval"
                 (buildRecordExpression
-                    [ ( "environment", generateTemplateEvaluatingToExpression parseAndEval.environment )
-                    , ( "expression", generateTemplateEvaluatingToExpression parseAndEval.expression )
+                    [ ( "environment", generateTemplateEvaluatingToExpression envExpr )
+                    , ( "expression", generateTemplateEvaluatingToExpression exprExpr )
                     ]
                 )
 
@@ -58,18 +58,18 @@ generateTemplateEvaluatingToExpression expression =
                     ]
                 )
 
-        Pine.ConditionalExpression conditional ->
+        Pine.ConditionalExpression condition ifFalse ifTrue ->
             buildFromTagAndArgument
                 "Conditional"
                 (buildRecordExpression
                     [ ( "condition"
-                      , generateTemplateEvaluatingToExpression conditional.condition
+                      , generateTemplateEvaluatingToExpression condition
                       )
                     , ( "ifFalse"
-                      , generateTemplateEvaluatingToExpression conditional.ifFalse
+                      , generateTemplateEvaluatingToExpression ifFalse
                       )
                     , ( "ifTrue"
-                      , generateTemplateEvaluatingToExpression conditional.ifTrue
+                      , generateTemplateEvaluatingToExpression ifTrue
                       )
                     ]
                 )
@@ -97,7 +97,7 @@ buildPineExpressionSyntax config expression =
                 Nothing
 
             else if FirCompiler.pineExpressionIsIndependent expression then
-                case Pine.evaluateExpression Pine.emptyEvalContext expression of
+                case Pine.evaluateExpression Pine.emptyEvalEnvironment expression of
                     Err _ ->
                         Nothing
 
@@ -232,16 +232,16 @@ buildPineExpressionSyntax config expression =
                         "Pine.ListExpression"
                         [ String.join "\n" listSyntax ]
 
-                Pine.ParseAndEvalExpression parseAndEval ->
+                Pine.ParseAndEvalExpression envExpr exprExpr ->
                     buildFromTagNameAndArguments
                         "Pine.ParseAndEvalExpression"
                         [ buildRecordSyntax
                             [ ( "environment"
-                              , buildPineExpressionSyntax config parseAndEval.environment
+                              , buildPineExpressionSyntax config envExpr
                                     |> String.join "\n"
                               )
                             , ( "expression"
-                              , buildPineExpressionSyntax config parseAndEval.expression
+                              , buildPineExpressionSyntax config exprExpr
                                     |> String.join "\n"
                               )
                             ]
@@ -263,20 +263,20 @@ buildPineExpressionSyntax config expression =
                             |> String.join "\n"
                         ]
 
-                Pine.ConditionalExpression conditional ->
+                Pine.ConditionalExpression condition ifFalse ifTrue ->
                     buildFromTagNameAndArguments
                         "Pine.ConditionalExpression"
                         [ buildRecordSyntax
                             [ ( "condition"
-                              , buildPineExpressionSyntax config conditional.condition
+                              , buildPineExpressionSyntax config condition
                                     |> String.join "\n"
                               )
                             , ( "ifFalse"
-                              , buildPineExpressionSyntax config conditional.ifFalse
+                              , buildPineExpressionSyntax config ifFalse
                                     |> String.join "\n"
                               )
                             , ( "ifTrue"
-                              , buildPineExpressionSyntax config conditional.ifTrue
+                              , buildPineExpressionSyntax config ifTrue
                                     |> String.join "\n"
                               )
                             ]

diff --git a/implement/pine/ElmTime/compile-elm-program/src/ElmInteractiveParser.elm b/implement/pine/ElmTime/compile-elm-program/src/ElmInteractiveParser.elm
@@ -33,7 +33,7 @@ import Pine
 import Result.Extra
 
 
-compileEvalContextForElmInteractive : InteractiveContext -> Result String Pine.EvalContext
+compileEvalContextForElmInteractive : InteractiveContext -> Result String Pine.EvalEnvironment
 compileEvalContextForElmInteractive context =
     let
         contextModulesTextsBatches : List (List String)
@@ -70,8 +70,8 @@ compileEvalContextForElmInteractive context =
                                 )
                     )
             )
-            (Ok Pine.emptyEvalContext.environment)
-        |> Result.map (\environmentValue -> { environment = environmentValue })
+            (Ok (Pine.ListValue []))
+        |> Result.map Pine.EvalEnvironment
 
 
 expandElmInteractiveEnvironmentWithModuleTexts :
@@ -105,7 +105,7 @@ submissionInInteractive context previousSubmissions submission =
             submissionWithHistoryInInteractive initialContext previousSubmissions submission
 
 
-submissionWithHistoryInInteractive : Pine.EvalContext -> List String -> String -> Result String SubmissionResponse
+submissionWithHistoryInInteractive : Pine.EvalEnvironment -> List String -> String -> Result String SubmissionResponse
 submissionWithHistoryInInteractive initialContext previousSubmissions submission =
     case previousSubmissions of
         [] ->
@@ -121,12 +121,12 @@ submissionWithHistoryInInteractive initialContext previousSubmissions submission
                     submissionWithHistoryInInteractive expressionContext remainingPreviousSubmissions submission
 
 
-submissionInInteractiveInPineContext : Pine.EvalContext -> String -> Result String ( Pine.EvalContext, SubmissionResponse )
-submissionInInteractiveInPineContext expressionContext submission =
-    compileInteractiveSubmission expressionContext.environment submission
+submissionInInteractiveInPineContext : Pine.EvalEnvironment -> String -> Result String ( Pine.EvalEnvironment, SubmissionResponse )
+submissionInInteractiveInPineContext (Pine.EvalEnvironment envValue) submission =
+    compileInteractiveSubmission envValue submission
         |> Result.andThen
             (\pineExpression ->
-                case Pine.evaluateExpression expressionContext pineExpression of
+                case Pine.evaluateExpression (Pine.EvalEnvironment envValue) pineExpression of
                     Err error ->
                         Err ("Failed to evaluate expression:\n" ++ Pine.displayStringFromPineError error)
 
@@ -135,7 +135,7 @@ submissionInInteractiveInPineContext expressionContext submission =
 
                     Ok (Pine.ListValue [ newState, responseValue ]) ->
                         submissionResponseFromResponsePineValue responseValue
-                            |> Result.map (Tuple.pair { environment = newState })
+                            |> Result.map (Tuple.pair (Pine.EvalEnvironment newState))
 
                     Ok (Pine.ListValue resultList) ->
                         Err