Merge pull request #636 from hackworthltd/georgefst/primitive-sum

 refactor: Use a sum type for primitive definitions

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, (^.))
+import Optics (ifoldr, over, traverseOf, view, (^.))
 import Primer.App (
   App,
   EditAppM,
@@ -107,10 +108,12 @@ import Primer.Core (
   Type,
   Type' (..),
   defAST,
-  defType,
   moduleNamePretty,
   unLocalName,
+  _typeMeta,
+  _typeMetaLens,
  )
+import Primer.Core qualified as Core
 import Primer.Database (
   OffsetLimit,
   Page,
@@ -146,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.
@@ -480,11 +484,20 @@ viewProg p =
         , editable = e
         , types = fst <$> Map.assocs (moduleTypesQualified m)
         , defs =
-            ( \(n, d) ->
+            ( \(name, d) ->
                 Def
-                  { name = n
-                  , type_ = viewTreeType $ defType d
+                  { name
                   , 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)
@@ -668,7 +681,12 @@ viewTreeExpr e0 = case e0 of
 
 -- | Similar to 'viewTreeExpr', but for 'Type's
 viewTreeType :: Type -> Tree
-viewTreeType t0 = case t0 of
+viewTreeType = viewTreeType' . over _typeMeta (show . view _id)
+
+-- | Like 'viewTreeType', but with the flexibility to accept arbitrary textual node identifiers,
+-- rather than using the type's numeric IDs.
+viewTreeType' :: Type' Text -> Tree
+viewTreeType' t0 = case t0 of
   TEmptyHole _ ->
     Tree
       { nodeId
@@ -682,7 +700,7 @@ viewTreeType t0 = case t0 of
       { nodeId
       , flavor = FlavorTHole
       , body = NoBody
-      , childTrees = [viewTreeType t]
+      , childTrees = [viewTreeType' t]
       , rightChild = Nothing
       }
   TCon _ n ->
@@ -698,7 +716,7 @@ viewTreeType t0 = case t0 of
       { nodeId
       , flavor = FlavorTFun
       , body = NoBody
-      , childTrees = [viewTreeType t1, viewTreeType t2]
+      , childTrees = [viewTreeType' t1, viewTreeType' t2]
       , rightChild = Nothing
       }
   TVar _ n ->
@@ -714,15 +732,15 @@ viewTreeType t0 = case t0 of
       { nodeId
       , flavor = FlavorTApp
       , body = NoBody
-      , childTrees = [viewTreeType t1, viewTreeType t2]
+      , childTrees = [viewTreeType' t1, viewTreeType' t2]
       , rightChild = Nothing
       }
   TForall _ n k t ->
     Tree
       { nodeId
       , flavor = FlavorTForall
       , body = TextBody $ withKindAnn $ unName $ unLocalName n
-      , childTrees = [viewTreeType t]
+      , childTrees = [viewTreeType' t]
       , rightChild = Nothing
       }
     where
@@ -733,7 +751,7 @@ viewTreeType t0 = case t0 of
         KType -> identity
         _ -> (<> (" :: " <> show k))
   where
-    nodeId = show $ t0 ^. _id
+    nodeId = t0 ^. _typeMetaLens
 
 showGlobal :: GlobalName k -> Text
 showGlobal n = moduleNamePretty (qualifiedModule n) <> "." <> unName (baseName n)

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,
   (%),
@@ -492,13 +486,29 @@ 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'.
-newtype PrimDef = PrimDef
-  { primDefType :: Type
-  }
-  deriving (Eq, Show, Data, Generic)
+-- For each of these, we should have a test that the evaluator produces expected results.
+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 +519,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 +541,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