refactor: Simplify primitives tests

Now that primitives don't contain metadata, we don't need to juggle state and DSL functions.

We also remove `allPrimDefs`, whise functionality has been subsumed by `primitiveModule`.

Author: georgefst

primer/src/Primer/Core.hs

@@ -486,9 +486,7 @@ data Def
 type DefMap = Map GVarName Def
 
 -- | A primitive, built-in definition.
--- Names and definitions of primitives are hard-coded in Primer.Primitives.
--- A @PrimDef@ simply exposes one of those, and thus the type must match
--- the one stored in the corresponding 'PrimFun'.
+-- For each of these, we should have a test that the evaluator produces expected results.
 data PrimDef
   = ToUpper
   | IsSpace

primer/src/Primer/Primitives.hs

@@ -11,7 +11,6 @@ module Primer.Primitives (
   primDefName,
   primDefType,
   defType,
-  allPrimDefs,
   primFunDef,
 ) where
 
@@ -75,7 +74,7 @@ primitiveModule =
   Module
     { moduleName = primitiveModuleName
     , moduleTypes = TypeDefPrim <$> M.mapKeys baseName allPrimTypeDefs
-    , moduleDefs = M.fromList $ [(baseName $ primDefName def, DefPrim def) | def <- enumerate]
+    , moduleDefs = M.fromList $ [(primDefName def, DefPrim def) | def <- enumerate]
     }
 
 tChar :: TyConName
@@ -84,7 +83,7 @@ tChar = primitive "Char"
 tInt :: TyConName
 tInt = primitive "Int"
 
--- | Construct a reference to a primitive definition. For use in tests.
+-- | Construct a reference to a primitive definition.
 primitiveGVar :: Name -> GVarName
 primitiveGVar = primitive
 
@@ -115,34 +114,28 @@ allPrimTypeDefs =
       PrimChar _ -> ()
       PrimInt _ -> ()
 
--- | Primitive term definitions.
--- For each of these, we should have a test that the evaluator produces expected results.
-allPrimDefs :: Map GVarName PrimDef
-allPrimDefs = M.fromList [(primDefName def, def) | def <- enumerate]
-
-primDefName :: PrimDef -> GVarName
-primDefName =
-  primitiveGVar . \case
-    ToUpper -> "toUpper"
-    IsSpace -> "isSpace"
-    HexToNat -> "hexToNat"
-    NatToHex -> "natToHex"
-    EqChar -> "eqChar"
-    IntAdd -> "Int.+"
-    IntMinus -> "Int.-"
-    IntMul -> "Int.×"
-    IntQuotient -> "Int.quotient"
-    IntRemainder -> "Int.remainder"
-    IntQuot -> "Int.quot"
-    IntRem -> "Int.rem"
-    IntLT -> "Int.<"
-    IntLTE -> "Int.≤"
-    IntGT -> "Int.>"
-    IntGTE -> "Int.≥"
-    IntEq -> "Int.="
-    IntNeq -> "Int.≠"
-    IntToNat -> "Int.toNat"
-    IntFromNat -> "Int.fromNat"
+primDefName :: PrimDef -> Name
+primDefName = \case
+  ToUpper -> "toUpper"
+  IsSpace -> "isSpace"
+  HexToNat -> "hexToNat"
+  NatToHex -> "natToHex"
+  EqChar -> "eqChar"
+  IntAdd -> "Int.+"
+  IntMinus -> "Int.-"
+  IntMul -> "Int.×"
+  IntQuotient -> "Int.quotient"
+  IntRemainder -> "Int.remainder"
+  IntQuot -> "Int.quot"
+  IntRem -> "Int.rem"
+  IntLT -> "Int.<"
+  IntLTE -> "Int.≤"
+  IntGT -> "Int.>"
+  IntGTE -> "Int.≥"
+  IntEq -> "Int.="
+  IntNeq -> "Int.≠"
+  IntToNat -> "Int.toNat"
+  IntFromNat -> "Int.fromNat"
 
 primDefType :: PrimDef -> Type' ()
 primDefType = uncurry (flip $ foldr $ TFun ()) . primFunTypes

primer/test/TestUtils.hs

@@ -3,7 +3,7 @@ module TestUtils (
   (@?=),
   ExceptionPredicate,
   assertException,
-  withPrimDefs,
+  primDefs,
   constructTCon,
   constructCon,
   constructRefinedCon,
@@ -22,9 +22,8 @@ import Foreword
 import Control.Concurrent.STM (
   newTBQueueIO,
  )
-import Control.Monad.Fresh (MonadFresh)
-import Data.Coerce (coerce)
-import Data.String (String, fromString)
+import Data.Map qualified as Map
+import Data.String (String)
 import Data.Typeable (typeOf)
 import Optics (over, set, view)
 import Primer.API (
@@ -36,14 +35,14 @@ import Primer.Action (
   Action (ConstructCon, ConstructRefinedCon, ConstructTCon),
  )
 import Primer.Core (
+  DefMap,
   Expr',
   ExprMeta,
   GVarName,
   GlobalName (baseName, qualifiedModule),
   HasID,
   HasMetadata (_metadata),
   ModuleName (ModuleName, unModuleName),
-  PrimDef (..),
   TyConName,
   Type',
   TypeMeta,
@@ -61,17 +60,18 @@ import Primer.Database (
   runNullDb',
   serve,
  )
+import Primer.Module (Module (moduleDefs))
 import Primer.Name (Name (unName))
-import Primer.Primitives (allPrimDefs)
+import Primer.Primitives (primitiveGVar, primitiveModule)
 import StmContainers.Map qualified as StmMap
 import Test.Tasty.HUnit (
   assertBool,
   assertFailure,
  )
 import Test.Tasty.HUnit qualified as HUnit
 
-withPrimDefs :: (Map GVarName PrimDef -> m a) -> m a
-withPrimDefs f = f allPrimDefs
+primDefs :: DefMap
+primDefs = Map.mapKeys primitiveGVar $ moduleDefs primitiveModule
 
 -- impedence mismatch: ConstructTCon takes text, but tChar etc are TyConNames
 constructTCon :: TyConName -> Action

primer/test/Tests/Eval.hs

@@ -34,6 +34,7 @@ import Primer.Core (
   Kind (KType),
   Type,
   TypeDef (TypeDefAST),
+  defPrim,
   getID,
   _id,
  )
@@ -65,7 +66,7 @@ import Primer.Primitives (primitiveGVar, primitiveModule, tChar)
 import Primer.Zipper (target)
 import Test.Tasty.HUnit (Assertion, assertBool, assertFailure, (@?=))
 import TestM (evalTestM)
-import TestUtils (gvn, vcn, withPrimDefs)
+import TestUtils (gvn, primDefs, vcn)
 import Tests.Action.Prog (runAppTestM)
 
 -- * 'tryReduce' tests
@@ -625,15 +626,14 @@ unit_tryReduce_case_no_matching_branch = do
 
 unit_tryReduce_prim :: Assertion
 unit_tryReduce_prim = do
-  let ((expr, expectedResult, globals), i) =
-        create . withPrimDefs $ \m ->
-          (,,)
+  let ((expr, expectedResult), i) =
+        create $
+          (,)
             <$> gvar (primitiveGVar "eqChar")
             `app` char 'a'
             `app` char 'a'
             <*> con cTrue
-            <*> pure m
-      result = runTryReduce (DefPrim <$> globals) mempty (expr, i)
+      result = runTryReduce primDefs mempty (expr, i)
   case result of
     Right (expr', ApplyPrimFun detail) -> do
       expr' ~= expectedResult
@@ -646,25 +646,21 @@ unit_tryReduce_prim = do
 
 unit_tryReduce_prim_fail_unsaturated :: Assertion
 unit_tryReduce_prim_fail_unsaturated = do
-  let ((expr, globals), i) =
-        create . withPrimDefs $ \m ->
-          (,)
-            <$> gvar (primitiveGVar "eqChar")
+  let (expr, i) =
+        create $
+          gvar (primitiveGVar "eqChar")
             `app` char 'a'
-            <*> pure m
-      result = runTryReduce (DefPrim <$> globals) mempty (expr, i)
+      result = runTryReduce primDefs mempty (expr, i)
   result @?= Left NotRedex
 
 unit_tryReduce_prim_fail_unreduced_args :: Assertion
 unit_tryReduce_prim_fail_unreduced_args = do
-  let ((expr, globals), i) =
-        create . withPrimDefs $ \m ->
-          (,)
-            <$> gvar (primitiveGVar "eqChar")
+  let (expr, i) =
+        create $
+          gvar (primitiveGVar "eqChar")
             `app` char 'a'
             `app` (gvar (primitiveGVar "toUpper") `app` char 'a')
-            <*> pure m
-      result = runTryReduce (DefPrim <$> globals) mempty (expr, i)
+      result = runTryReduce primDefs mempty (expr, i)
   result @?= Left NotRedex
 
 -- One can call the eval-step api endpoint with an expression and ID
@@ -859,7 +855,7 @@ redexesOf = redexes mempty . create'
 
 -- | A variation of 'redexesOf' for when the expression tested requires primitives to be in scope.
 redexesOfWithPrims :: S Expr -> Set ID
-redexesOfWithPrims x = uncurry redexes $ create' $ withPrimDefs $ \globals -> (globals,) <$> x
+redexesOfWithPrims = redexes (Map.mapMaybe defPrim primDefs) . create'
 
 unit_redexes_con :: Assertion
 unit_redexes_con = redexesOf (con' ["M"] "C") @?= mempty