splitClosureTy,
mkPADictType, mkPArrayType,
paDictArgType, paDictOfType,
+ paMethod, lengthPA, replicatePA, emptyPA,
+ abstractOverTyVars, applyToTypes,
lookupPArrayFamInst,
- hoistExpr
+ hoistExpr, takeHoisted
) where
#include "HsVersions.h"
import Outputable
import FastString
-import Control.Monad ( liftM )
+import Control.Monad ( liftM, zipWithM_ )
collectAnnTypeArgs :: AnnExpr b ann -> (AnnExpr b ann, [Type])
collectAnnTypeArgs expr = go expr []
isAnnTypeArg _ = False
isClosureTyCon :: TyCon -> Bool
-isClosureTyCon tc = tyConUnique tc == closureTyConKey
+isClosureTyCon tc = tyConName tc == closureTyConName
splitClosureTy :: Type -> (Type, Type)
splitClosureTy ty
| otherwise = pprPanic "splitClosureTy" (ppr ty)
+isPArrayTyCon :: TyCon -> Bool
+isPArrayTyCon tc = tyConName tc == parrayTyConName
+
+splitPArrayTy :: Type -> Type
+splitPArrayTy ty
+ | Just (tc, [arg_ty]) <- splitTyConApp_maybe ty
+ , isPArrayTyCon tc
+ = arg_ty
+
+ | otherwise = pprPanic "splitPArrayTy" (ppr ty)
+
mkPADictType :: Type -> VM Type
mkPADictType ty
= do
dicts <- mapM paDictOfType tys
return $ mkApps (mkTyApps dfun tys) dicts
+paMethod :: (Builtins -> Var) -> Type -> VM CoreExpr
+paMethod method ty
+ = do
+ fn <- builtin method
+ dict <- paDictOfType ty
+ return $ mkApps (Var fn) [Type ty, dict]
+
+lengthPA :: CoreExpr -> VM CoreExpr
+lengthPA x = liftM (`App` x) (paMethod lengthPAVar ty)
+ where
+ ty = splitPArrayTy (exprType x)
+
+replicatePA :: CoreExpr -> CoreExpr -> VM CoreExpr
+replicatePA len x = liftM (`mkApps` [len,x])
+ (paMethod replicatePAVar (exprType x))
+
+emptyPA :: Type -> VM CoreExpr
+emptyPA = paMethod emptyPAVar
+
+abstractOverTyVars :: [TyVar] -> ((CoreExpr -> CoreExpr) -> VM a) -> VM a
+abstractOverTyVars tvs p
+ = do
+ mdicts <- mapM mk_dict_var tvs
+ zipWithM_ (\tv -> maybe (defLocalTyVar tv) (defLocalTyVarWithPA tv . Var)) tvs mdicts
+ p (mk_lams mdicts)
+ where
+ mk_dict_var tv = do
+ r <- paDictArgType tv
+ case r of
+ Just ty -> liftM Just (newLocalVar FSLIT("dPA") ty)
+ Nothing -> return Nothing
+
+ mk_lams mdicts = mkLams (tvs ++ [dict | Just dict <- mdicts])
+
+applyToTypes :: CoreExpr -> [Type] -> VM CoreExpr
+applyToTypes expr tys
+ = do
+ dicts <- mapM paDictOfType tys
+ return $ expr `mkTyApps` tys `mkApps` dicts
+
lookupPArrayFamInst :: Type -> VM (TyCon, [Type])
lookupPArrayFamInst ty = builtin parrayTyCon >>= (`lookupFamInst` [ty])
hoistExpr fs expr
= do
var <- newLocalVar fs (exprType expr)
- updLEnv $ \env ->
- env { local_bindings = (var, expr) : local_bindings env }
+ updGEnv $ \env ->
+ env { global_bindings = (var, expr) : global_bindings env }
return var
+takeHoisted :: VM [(Var, CoreExpr)]
+takeHoisted
+ = do
+ env <- readGEnv id
+ setGEnv $ env { global_bindings = [] }
+ return $ global_bindings env
+