refactor: Use an enum type for primitive definitions

This makes our primitives system more elegant and robust.

The core problem with the old approach was that because primitive definitions and their semantics were only tied together by strings, utilising them could often result in partial functions being necessary in awkward places. This would have become clear in upcoming work to build our prelude library.

A side effect needed to make this work is that the types of primitive definitions no longer contain metadata. As can be seen in this commit, this has very few knock-on effects: seeing as a user can't manipulate these types, we never did anythin interesting with the metadata anyway. Indeed, some code becomes cleaner as a result.

We also remove some tests of behaviour which is nowz correct by construction.

Author: georgefst

primer/gen/Primer/Gen/App.hs

@@ -10,10 +10,11 @@ module Primer.Gen.App (
 ) where
 
 import Primer.App (Prog (Prog, progImports, progLog, progModules, progSelection, progSmartHoles), defaultLog)
-import Primer.Core (ASTDef (ASTDef), Def (DefAST), GlobalName (baseName), Kind (KType), ModuleName (ModuleName), defType, qualifyName)
+import Primer.Core (ASTDef (ASTDef), Def (DefAST), GlobalName (baseName), Kind (KType), ModuleName (ModuleName), qualifyName)
 import Primer.Core.Utils (forgetTypeMetadata, generateIDs, generateTypeIDs)
 import Primer.Module (Module (Module, moduleDefs, moduleName, moduleTypes), moduleDefsQualified, moduleTypesQualified)
 import Primer.Name (Name, unsafeMkName)
+import Primer.Primitives (defType)
 import Primer.Typecheck (Cxt, SmartHoles, extendGlobalCxt, extendTypeDefCxt)
 
 import Primer.Gen.Core.Typed (WT, freshNameForCxt, genChk, genTypeDefGroup, genWTType)

primer/src/Primer/API.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE BlockArguments #-}
 {-# LANGUAGE GADTs #-}
 
 -- | The Primer API.
@@ -63,7 +64,7 @@ import Control.Monad.Zip (MonadZip)
 import Data.Map qualified as Map
 import Data.Text qualified as T
 import ListT qualified (toList)
-import Optics (ifoldr, over, view, (^.))
+import Optics (ifoldr, over, traverseOf, view, (^.))
 import Primer.App (
   App,
   EditAppM,
@@ -107,12 +108,12 @@ import Primer.Core (
   Type,
   Type' (..),
   defAST,
-  defType,
   moduleNamePretty,
   unLocalName,
   _typeMeta,
   _typeMetaLens,
  )
+import Primer.Core qualified as Core
 import Primer.Database (
   OffsetLimit,
   Page,
@@ -148,6 +149,7 @@ import Primer.JSON (
  )
 import Primer.Module (moduleDefsQualified, moduleName, moduleTypesQualified)
 import Primer.Name (Name, unName)
+import Primer.Primitives (primDefType)
 import StmContainers.Map qualified as StmMap
 
 -- | The API environment.
@@ -485,8 +487,17 @@ viewProg p =
             ( \(name, d) ->
                 Def
                   { name
-                  , type_ = viewTreeType $ defType d
                   , term = viewTreeExpr . astDefExpr <$> defAST d
+                  , type_ =
+                      case d of
+                        Core.DefAST d' -> viewTreeType $ astDefType d'
+                        Core.DefPrim d' -> viewTreeType' $ labelNodes $ primDefType d'
+                          where
+                            labelNodes =
+                              flip evalState (0 :: Int) . traverseOf _typeMeta \() -> do
+                                n <- get
+                                put $ n + 1
+                                pure $ "primtype_" <> show d' <> "_" <> show n
                   }
             )
               <$> Map.assocs (moduleDefsQualified m)

primer/src/Primer/Core.hs

@@ -12,8 +12,6 @@ module Primer.Core (
   CaseBranch' (..),
   Def (..),
   DefMap,
-  _defType,
-  defType,
   ASTDef (..),
   defAST,
   PrimDef (..),
@@ -55,8 +53,6 @@ module Primer.Core (
   PrimTypeDef (..),
   PrimCon (..),
   primConName,
-  PrimFun (..),
-  primFunType,
   PrimFunError (..),
   ValCon (..),
   valConType,
@@ -78,7 +74,6 @@ module Primer.Core (
 
 import Foreword
 
-import Control.Monad.Fresh (MonadFresh (fresh))
 import Data.Aeson (Value)
 import Data.Data (Data)
 import Data.Generics.Product
@@ -93,7 +88,6 @@ import Optics (
   afailing,
   atraversalVL,
   lens,
-  lensVL,
   set,
   view,
   (%),
@@ -495,10 +489,28 @@ type DefMap = Map GVarName Def
 -- 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'.
-newtype PrimDef = PrimDef
-  { primDefType :: Type
-  }
-  deriving (Eq, Show, Data, Generic)
+data PrimDef
+  = ToUpper
+  | IsSpace
+  | HexToNat
+  | NatToHex
+  | EqChar
+  | IntAdd
+  | IntMinus
+  | IntMul
+  | IntQuotient
+  | IntRemainder
+  | IntQuot
+  | IntRem
+  | IntLT
+  | IntLTE
+  | IntGT
+  | IntGTE
+  | IntEq
+  | IntNeq
+  | IntToNat
+  | IntFromNat
+  deriving (Eq, Show, Enum, Bounded, Data, Generic)
   deriving (FromJSON, ToJSON) via PrimerJSON PrimDef
 
 -- | A top-level definition, built from an 'Expr'
@@ -509,12 +521,6 @@ data ASTDef = ASTDef
   deriving (Eq, Show, Data, Generic)
   deriving (FromJSON, ToJSON) via PrimerJSON ASTDef
 
-_defType :: Lens' Def Type
-_defType = lensVL $ \f -> \case
-  DefPrim (PrimDef t) -> DefPrim . PrimDef <$> f t
-  DefAST (ASTDef e t) -> DefAST . ASTDef e <$> f t
-defType :: Def -> Type
-defType = view _defType
 defAST :: Def -> Maybe ASTDef
 defAST = \case
   DefPrim _ -> Nothing
@@ -537,26 +543,10 @@ primConName = \case
   PrimChar _ -> qualifyName (mkSimpleModuleName "Primitives") "Char"
   PrimInt _ -> qualifyName (mkSimpleModuleName "Primitives") "Int"
 
-data PrimFun = PrimFun
-  { primFunTypes :: forall m. MonadFresh ID m => m ([Type], Type)
-  -- ^ the function's arguments and return type
-  , primFunDef :: [Expr' () ()] -> Either PrimFunError (forall m. MonadFresh ID m => m Expr)
-  }
-
-primFunType :: forall m. MonadFresh ID m => PrimFun -> m Type
-primFunType pf = do
-  (args, res) <- primFunTypes pf
-  foldrM f res args
-  where
-    f x y = do
-      id <- fresh
-      pure $ TFun (Meta id Nothing Nothing) x y
-
 data PrimFunError
   = -- | We have attempted to apply a primitive function to invalid args.
     PrimFunError
-      GVarName
-      -- ^ Function name
+      PrimDef
       [Expr' () ()]
       -- ^ Arguments
   deriving (Eq, Show, Data, Generic)

primer/src/Primer/Core/Utils.hs

@@ -60,7 +60,6 @@ import Primer.Core (
   Kind (KHole),
   LVarName,
   LocalName (LocalName, unLocalName),
-  PrimDef (..),
   TmVarRef (GlobalVarRef, LocalVarRef),
   TyVarName,
   Type,
@@ -271,5 +270,5 @@ nextID (DefAST (ASTDef e t)) =
   let eid = foldlOf' exprIDs max minBound e
       tid = foldlOf' typeIDs max minBound t
    in succ $ max eid tid
-nextID (DefPrim (PrimDef t)) = succ $ foldlOf' typeIDs max minBound t
+nextID (DefPrim _) = 0
 {-# INLINE nextID #-}

primer/src/Primer/Eval.hs

@@ -63,8 +63,6 @@ import Primer.Core (
   LocalName (LocalName, unLocalName),
   LocalNameKind (..),
   Meta,
-  PrimDef (..),
-  PrimFun (..),
   PrimFunError (..),
   TmVarRef (..),
   TyVarName,
@@ -95,7 +93,7 @@ import Primer.Core.Utils (
 import Primer.JSON
 import Primer.Name (Name, unName, unsafeMkName)
 import Primer.Name.Fresh (isFresh, isFreshTy)
-import Primer.Primitives (allPrimDefs)
+import Primer.Primitives (PrimDef, primFunDef)
 import Primer.Zipper (
   ExprZ,
   FoldAbove,
@@ -989,9 +987,8 @@ tryPrimFun :: Map GVarName PrimDef -> Expr -> Maybe (GVarName, [Expr], forall m.
 tryPrimFun primDefs expr
   | -- Since no primitive functions are polymorphic, there is no need to unfoldAPP
     (Var _ (GlobalVarRef name), args) <- bimap stripAnns (map stripAnns) $ unfoldApp expr
-  , Map.member name primDefs
-  , Just PrimFun{primFunDef} <- Map.lookup name allPrimDefs
-  , Right e <- primFunDef $ forgetMetadata <$> args =
+  , Just x <- Map.lookup name primDefs
+  , Right e <- primFunDef x $ forgetMetadata <$> args =
       Just (name, args, e)
   | otherwise = Nothing
   where