Rename CodeResult to EvalResult with its accessor functions.

Author: Unisay

doc/docusaurus/docs/using-plinth/evaluating-plinth.md

@@ -31,10 +31,10 @@ So that we can import the necessary functionality:
 
 ```haskell
 import PlutusTx.Test (
-  CodeResult,
+  EvalResult,
   applyLifted,
   evaluateCompiledCode,
-  prettyCodeResult
+  prettyEvalResult
  )
 ```
 
@@ -45,35 +45,35 @@ It is possible to evaluate this compiled code without applying it to any argumen
 and evaluation will succeed, returning the value of type `Integer -> Integer`:
 
 ```haskell
-result :: CodeResult
+result :: EvalResult
 result = evaluateCompiledCode compiledCode
 ```
 
-The `CodeResult` type is declared as follows:
+The `EvalResult` type is declared as follows:
 
 ```haskell
-data CodeResult = CodeResult
-  { codeResult
+data EvalResult = EvalResult
+  { evalResult
       :: Either
            (CekEvaluationException NamedDeBruijn DefaultUni DefaultFun)
            (NTerm DefaultUni DefaultFun ())
-  , codeBudget :: ExBudget
-  , codeTraces :: [Text]
+  , evalResultBudget :: ExBudget
+  , evalResultTraces :: [Text]
   }
   deriving stock (Show)
 ```
 
-The `codeResult` field contains the result of the evaluation, which can either be a successful evaluation or an error.
+The `evalResult` field contains the result of the evaluation, which can either be a successful evaluation or an error.
 
-The `codeBudget` field contains the execution budget used during the evaluation,
+The `evalResultBudget` field contains the execution budget used during the evaluation,
 which includes the CPU and memory usage.
 
-The `codeTraces` field contains the traces emitted during the evaluation.
+The `evalResultTraces` field contains the traces emitted during the evaluation.
 
 One can use its `Show` instance to print the result of the evaluation:
 ```haskell
-CodeResult
-  { codeResult =
+EvalResult
+  { evalResult =
       Right
         ( LamAbs
             ()
@@ -110,17 +110,17 @@ CodeResult
                 )
             )
         )
-  , codeBudget =
+  , evalResultBudget =
       ExBudget
         { exBudgetCPU = ExCPU 16100
         , exBudgetMemory = ExMemory 200
         }
-  , codeTraces = []
+  , evalResultTraces = []
   }
 ```
 
 The output is quite verbose and not very readable.
-To make it more readable, we can use the `prettyCodeResult` function, 
+To make it more readable, we can use the `prettyEvalResult` function, 
 which formats the output in a prettier way:
 
 ```

doc/docusaurus/static/code/Example/Evaluation/Main.hs

@@ -16,7 +16,7 @@ import PlutusTx.Plugin (plc)
 import PlutusTx.Prelude
 import Prelude (IO)
 
-import PlutusTx.Test (CodeResult, applyLifted, evaluateCompiledCode, prettyCodeResult)
+import PlutusTx.Test (EvalResult, applyLifted, evaluateCompiledCode, prettyEvalResult)
 
 -- BEGIN Plinth
 plinthCode :: Integer -> Integer
@@ -27,30 +27,30 @@ compiledCode = plc (Proxy @"plinth") plinthCode
 -- END Plinth
 
 {-
-CodeResult
-    { codeResult = Right
+EvalResult
+    { evalResult = Right
         ( Constant ()
             ( Some
                 ( ValueOf DefaultUniInteger 4 )
             )
         )
-    , codeBudget = ExBudget
+    , evalResultBudget = ExBudget
         { exBudgetCPU = ExCPU 508304
         , exBudgetMemory = ExMemory 1966
         }
-    , codeTraces =
+    , evalResultTraces =
         [ "Evaluating x"
         , "Evaluating constant"
         ]
     }
 -}
 
 -- BEGIN AppliedResult
-result :: CodeResult
+result :: EvalResult
 result = evaluateCompiledCode $ compiledCode `applyLifted` 2
 -- END AppliedResult
 
 -- BEGIN main
 main :: IO ()
-main = Text.putStrLn $ prettyCodeResult result
+main = Text.putStrLn $ prettyEvalResult result
 -- END main

plutus-tx-plugin/test/AssocMap/Properties3.hs

@@ -30,7 +30,7 @@ import PlutusTx.IsData qualified as P
 import PlutusTx.Lift (liftCodeDef)
 import PlutusTx.List qualified as PlutusTx
 import PlutusTx.Prelude qualified as PlutusTx
-import PlutusTx.Test.Run.Code (codeResult, evaluateCompiledCode, evaluationResultMatchesHaskell)
+import PlutusTx.Test.Run.Code (evalResult, evaluateCompiledCode, evaluationResultMatchesHaskell)
 import PlutusTx.TH (compile)
 
 import PlutusTx.These (These (..))
@@ -222,9 +222,9 @@ builtinDataEncodingSpec = property $ do
   assocMapS <- forAll genAssocMapS
   let assocMap = semanticsToAssocMap assocMapS
       dataAssocMap = semanticsToDataAssocMap assocMapS
-      evalResult = codeResult . evaluateCompiledCode
-  evalResult (encodedDataAssocMap `unsafeApplyCode` liftCodeDef dataAssocMap)
-    === evalResult (encodedAssocMap `unsafeApplyCode` liftCodeDef assocMap)
+      eval = evalResult . evaluateCompiledCode
+  eval (encodedDataAssocMap `unsafeApplyCode` liftCodeDef dataAssocMap)
+    === eval (encodedAssocMap `unsafeApplyCode` liftCodeDef assocMap)
   evaluationResultMatchesHaskell
     (mDecodedAssocMap `unsafeApplyCode` liftCodeDef assocMap)
     (===)

plutus-tx-plugin/test/ShortCircuit/Spec.hs

@@ -14,7 +14,7 @@ import Control.Lens ((&))
 import PlutusCore.Default (DefaultFun, DefaultUni)
 import PlutusTx.Code (CompiledCode, unsafeApplyCode)
 import PlutusTx.Lift (liftCodeDef)
-import PlutusTx.Test.Run.Code (codeResult, evaluateCompiledCode)
+import PlutusTx.Test.Run.Code (evalResult, evaluateCompiledCode)
 import PlutusTx.TH (compile)
 import Test.Tasty (TestTree, testGroup)
 import Test.Tasty.HUnit (Assertion, assertEqual, assertFailure, testCase)
@@ -47,7 +47,7 @@ tests =
 
 assertResult :: NTerm DefaultUni DefaultFun () -> CompiledCode a -> Assertion
 assertResult expected code =
-  case codeResult (evaluateCompiledCode code) of
+  case evalResult (evaluateCompiledCode code) of
     Left ex      -> assertFailure $ show ex
     Right actual -> assertEqual "Evaluation has succeeded" expected actual
 

plutus-tx/testlib/PlutusTx/Test/Golden.hs

@@ -1,9 +1,9 @@
-{-# LANGUAGE FlexibleContexts #-}
-{-# LANGUAGE KindSignatures #-}
+{-# LANGUAGE FlexibleContexts      #-}
+{-# LANGUAGE KindSignatures        #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TypeApplications #-}
-{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE OverloadedStrings     #-}
+{-# LANGUAGE TypeApplications      #-}
+{-# LANGUAGE TypeOperators         #-}
 
 module PlutusTx.Test.Golden (
   -- * Compilation testing
@@ -35,31 +35,12 @@ import Data.Text (Text)
 import Flat (Flat)
 import PlutusCore qualified as PLC
 import PlutusCore.Evaluation.Machine.ExBudget qualified as PLC
-import PlutusCore.Pretty (
-  Pretty (pretty),
-  PrettyBy (prettyBy),
-  PrettyConfigClassic,
-  PrettyConfigName,
-  PrettyUni,
-  Render (render),
-  prettyClassicSimple,
-  prettyPlcClassicSimple,
-  prettyReadable,
-  prettyReadableSimple,
- )
-import PlutusCore.Test (
-  TestNested,
-  ToUPlc (..),
-  goldenSize,
-  goldenTPlc,
-  goldenUPlc,
-  goldenUPlcReadable,
-  nestedGoldenVsDoc,
-  nestedGoldenVsDocM,
-  ppCatch,
-  rethrow,
-  runUPlcBudget,
- )
+import PlutusCore.Pretty (Pretty (pretty), PrettyBy (prettyBy), PrettyConfigClassic,
+                          PrettyConfigName, PrettyUni, Render (render), prettyClassicSimple,
+                          prettyPlcClassicSimple, prettyReadable, prettyReadableSimple)
+import PlutusCore.Test (TestNested, ToUPlc (..), goldenSize, goldenTPlc, goldenUPlc,
+                        goldenUPlcReadable, nestedGoldenVsDoc, nestedGoldenVsDocM, ppCatch, rethrow,
+                        runUPlcBudget)
 import PlutusIR.Core.Type (progTerm)
 import PlutusIR.Test ()
 import PlutusTx.Code (CompiledCode, CompiledCodeIn, getPir, getPirNoAnn)

plutus-tx/testlib/PlutusTx/Test/Run/Code.hs

@@ -30,28 +30,28 @@ import UntypedPlutusCore.Evaluation.Machine.Cek (CekEvaluationException, Countin
                                                  logEmitter)
 import UntypedPlutusCore.Evaluation.Machine.Cek.Internal (NTerm, runCekDeBruijn)
 
-data CodeResult = CodeResult
-  { codeResult
+data EvalResult = EvalResult
+  { evalResult
       :: Either
            (CekEvaluationException NamedDeBruijn DefaultUni DefaultFun)
            (NTerm DefaultUni DefaultFun ())
-  , codeBudget :: ExBudget
-  , codeTraces :: [Text]
+  , evalResultBudget :: ExBudget
+  , evalResultTraces :: [Text]
   }
   deriving stock (Show)
 
-instance Pretty CodeResult where
+instance Pretty EvalResult where
   pretty
-    CodeResult
-      { codeBudget =
+    EvalResult
+      { evalResultBudget =
         ExBudget
           { exBudgetCPU = ExCPU cpu
           , exBudgetMemory = ExMemory mem
           }
       , ..
       } =
       vsep
-        [ case codeResult of
+        [ case evalResult of
             Left err ->
               vsep
                 [ "Evaluation FAILED:"
@@ -70,39 +70,39 @@ instance Pretty CodeResult where
               , "MEM" <+> pretty (format commas (unSatInt mem))
               ]
         , mempty
-        , if null codeTraces
+        , if null evalResultTraces
             then "No traces were emitted"
             else
               vsep
                 [ "Evaluation"
-                    <+> plural "trace" "traces" (length codeTraces)
+                    <+> plural "trace" "traces" (length evalResultTraces)
                     <> ":"
                 , indent 2 $
                     vsep $
                       zipWith
                         (\idx trace -> pretty idx <> dot <+> pretty trace)
                         [1 :: Int ..]
-                        codeTraces
+                        evalResultTraces
                 ]
         , mempty
         ]
 
-prettyCodeResult :: CodeResult -> Text
-prettyCodeResult = display
+prettyEvalResult :: EvalResult -> Text
+prettyEvalResult = display
 
-evaluateCompiledCode :: CompiledCode a -> CodeResult
-evaluateCompiledCode code = CodeResult{..}
+evaluateCompiledCode :: CompiledCode a -> EvalResult
+evaluateCompiledCode code = EvalResult{..}
  where
   term = getPlc code ^. progTerm
   params = defaultCekParametersForTesting
-  (codeResult, CountingSt codeBudget, codeTraces) =
+  (evalResult, CountingSt evalResultBudget, evalResultTraces) =
     runCekDeBruijn params counting logEmitter term
 
 evaluatesToError :: CompiledCode a -> Bool
 evaluatesToError = not . evaluatesWithoutError
 
 evaluatesWithoutError :: CompiledCode a -> Bool
-evaluatesWithoutError code = isRight (codeResult (evaluateCompiledCode code))
+evaluatesWithoutError code = isRight (evalResult (evaluateCompiledCode code))
 
 {-| Evaluate 'CompiledCode' and check that the result matches a given Haskell value
    (perhaps obtained by running the Haskell code that the term was compiled
@@ -126,28 +126,28 @@ evaluationResultMatchesHaskell actual =
 assertEvaluatesSuccessfully :: CompiledCode a -> Assertion
 assertEvaluatesSuccessfully code = do
   case evaluateCompiledCode code of
-    CodeResult{codeResult = Right _} -> pure ()
-    CodeResult{codeResult = Left err, codeTraces} ->
+    EvalResult{evalResult = Right _} -> pure ()
+    EvalResult{evalResult = Left err, evalResultTraces} ->
       assertFailure $
         Text.unpack $
           Text.unlines
             [ "Evaluation failed with an error:"
             , render (prettyPlcClassicSimple err)
             , "Evaluation traces:"
-            , Text.unlines codeTraces
+            , Text.unlines evalResultTraces
             ]
 
 assertEvaluatesWithError :: CompiledCode a -> Assertion
 assertEvaluatesWithError code = do
   case evaluateCompiledCode code of
-    CodeResult{codeResult = Left _} -> pure ()
-    CodeResult{codeResult = Right _, codeTraces} ->
+    EvalResult{evalResult = Left _} -> pure ()
+    EvalResult{evalResult = Right _, evalResultTraces} ->
       assertFailure $
         Text.unpack $
           Text.unlines
             [ "Evaluation succeeded, but expected an error."
             , "Evaluation traces:"
-            , Text.unlines codeTraces
+            , Text.unlines evalResultTraces
             ]
 
 --------------------------------------------------------------------------------