import HscTypes ( TypeEnv, extendTypeEnvList, typeEnvTyCons )
import CoreSyn
import CoreUtils
+import BuildTyCl
import DataCon
import TyCon
import Type
import Id ( mkWildId )
import Name ( Name, getOccName )
import NameEnv
-import TysWiredIn ( intTy, intDataCon )
+import TysWiredIn ( unitTy, unitTyCon, intTy, intDataCon, unitDataConId )
import TysPrim ( intPrimTy )
import Unique
import Outputable
import Control.Monad ( liftM, liftM2, zipWithM, zipWithM_ )
-import Data.List ( inits, tails, zipWith4 )
+import Data.List ( inits, tails, zipWith4, zipWith5 )
-- ----------------------------------------------------------------------------
-- Types
let orig_tcs = keep_tcs ++ conv_tcs
vect_tcs = keep_tcs ++ new_tcs
+ repr_tcs <- zipWithM buildPReprTyCon orig_tcs vect_tcs
parr_tcs <- zipWithM buildPArrayTyCon orig_tcs vect_tcs
dfuns <- mapM mkPADFun vect_tcs
defTyConPAs (zip vect_tcs dfuns)
- binds <- sequence (zipWith4 buildTyConBindings orig_tcs vect_tcs parr_tcs dfuns)
-
- let all_new_tcs = new_tcs ++ parr_tcs
+ binds <- sequence (zipWith5 buildTyConBindings orig_tcs
+ vect_tcs
+ repr_tcs
+ parr_tcs
+ dfuns)
+
+ let all_new_tcs = new_tcs ++ repr_tcs ++ parr_tcs
let new_env = extendTypeEnvList env
(map ATyCon all_new_tcs
++ [ADataCon dc | tc <- all_new_tcs
, dc <- tyConDataCons tc])
- return (new_env, map mkLocalFamInst parr_tcs, concat binds)
+ return (new_env, map mkLocalFamInst (repr_tcs ++ parr_tcs), concat binds)
where
tycons = typeEnvTyCons env
groups = tyConGroups tycons
name' <- cloneName mkVectTyConOcc name
rhs' <- vectAlgTyConRhs (algTyConRhs tc)
- return $ mkAlgTyCon name'
- kind
- tyvars
- [] -- no stupid theta
- rhs'
- [] -- no selector ids
- NoParentTyCon -- FIXME
- rec_flag -- FIXME: is this ok?
- False -- FIXME: no generics
- False -- not GADT syntax
+ liftDs $ buildAlgTyCon name'
+ tyvars
+ [] -- no stupid theta
+ rhs'
+ rec_flag -- FIXME: is this ok?
+ False -- FIXME: no generics
+ False -- not GADT syntax
+ Nothing -- not a family instance
where
name = tyConName tc
- kind = tyConKind tc
tyvars = tyConTyVars tc
rec_flag = boolToRecFlag (isRecursiveTyCon tc)
name' <- cloneName mkVectDataConOcc name
tycon' <- vectTyCon tycon
arg_tys <- mapM vectType rep_arg_tys
- wrk_name <- cloneName mkDataConWorkerOcc name'
-
- let ids = mkDataConIds (panic "vectDataCon: wrapper id")
- wrk_name
- data_con
- data_con = mkDataCon name'
- False -- not infix
- (map (const NotMarkedStrict) arg_tys)
- [] -- no labelled fields
- univ_tvs
- [] -- no existential tvs for now
- [] -- no eq spec for now
- [] -- no theta
- arg_tys
- tycon'
- [] -- no stupid theta
- ids
- return data_con
+
+ liftDs $ buildDataCon name'
+ False -- not infix
+ (map (const NotMarkedStrict) arg_tys)
+ [] -- no labelled fields
+ univ_tvs
+ [] -- no existential tvs for now
+ [] -- no eq spec for now
+ [] -- no context
+ arg_tys
+ tycon'
where
name = dataConName dc
univ_tvs = dataConUnivTyVars dc
rep_arg_tys = dataConRepArgTys dc
tycon = dataConTyCon dc
+mk_fam_inst :: TyCon -> TyCon -> (TyCon, [Type])
+mk_fam_inst fam_tc arg_tc
+ = (fam_tc, [mkTyConApp arg_tc . mkTyVarTys $ tyConTyVars arg_tc])
+
+buildPReprTyCon :: TyCon -> TyCon -> VM TyCon
+buildPReprTyCon orig_tc vect_tc
+ = do
+ name <- cloneName mkPReprTyConOcc (tyConName orig_tc)
+ rhs_ty <- buildPReprType vect_tc
+ prepr_tc <- builtin preprTyCon
+ liftDs $ buildSynTyCon name
+ tyvars
+ (SynonymTyCon rhs_ty)
+ (Just $ mk_fam_inst prepr_tc vect_tc)
+ where
+ tyvars = tyConTyVars vect_tc
+
+buildPReprType :: TyCon -> VM Type
+buildPReprType = liftM repr_type . mkTyConRepr
+
+buildToPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr
+buildToPRepr (TyConRepr {
+ repr_tys = repr_tys
+ , repr_prod_data_cons = prod_data_cons
+ , repr_prod_tys = prod_tys
+ , repr_sum_data_cons = sum_data_cons
+ , repr_type = repr_type
+ })
+ vect_tc prepr_tc _
+ = do
+ arg <- newLocalVar FSLIT("x") arg_ty
+ vars <- mapM (mapM (newLocalVar FSLIT("x"))) repr_tys
+
+ return . Lam arg
+ . wrapFamInstBody prepr_tc var_tys
+ . Case (Var arg) (mkWildId arg_ty) repr_type
+ . mk_alts data_cons vars
+ . zipWith3 mk_prod prod_data_cons repr_tys $ map (map Var) vars
+ where
+ var_tys = mkTyVarTys $ tyConTyVars vect_tc
+ arg_ty = mkTyConApp vect_tc var_tys
+ data_cons = tyConDataCons vect_tc
+
+ mk_alts _ _ [] = [(DEFAULT, [], Var unitDataConId)]
+ mk_alts [dc] [vars] [expr] = [(DataAlt dc, vars, expr)]
+ mk_alts dcs vars exprs = zipWith4 mk_alt dcs vars sum_data_cons exprs
+
+ mk_alt dc vars sum_dc expr = (DataAlt dc, vars,
+ mkConApp sum_dc (map Type prod_tys ++ [expr]))
+
+ mk_prod _ _ [] = Var unitDataConId
+ mk_prod _ _ [expr] = expr
+ mk_prod (Just dc) tys exprs = mkConApp dc (map Type tys ++ exprs)
+
+buildFromPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr
+buildFromPRepr (TyConRepr {
+ repr_tys = repr_tys
+ , repr_prod_data_cons = prod_data_cons
+ , repr_prod_tys = prod_tys
+ , repr_sum_data_cons = sum_data_cons
+ , repr_type = repr_type
+ })
+ vect_tc prepr_tc _
+ = do
+ arg_ty <- mkPReprType res_ty
+ arg <- newLocalVar FSLIT("x") arg_ty
+
+ liftM (Lam arg
+ . un_sum (unwrapFamInstScrut prepr_tc var_tys (Var arg)))
+ (sequence
+ $ zipWith4 un_prod data_cons prod_data_cons prod_tys repr_tys)
+ where
+ var_tys = mkTyVarTys $ tyConTyVars vect_tc
+ ty_args = map Type var_tys
+ res_ty = mkTyConApp vect_tc var_tys
+ data_cons = tyConDataCons vect_tc
+
+ un_prod dc _ _ []
+ = do
+ var <- newLocalVar FSLIT("u") unitTy
+ return (var, mkConApp dc ty_args)
+ un_prod dc _ _ [ty]
+ = do
+ var <- newLocalVar FSLIT("x") ty
+ return (var, mkConApp dc (ty_args ++ [Var var]))
+
+ un_prod dc (Just prod_dc) prod_ty tys
+ = do
+ vars <- mapM (newLocalVar FSLIT("x")) tys
+ pv <- newLocalVar FSLIT("p") prod_ty
+
+ let res = mkConApp dc (ty_args ++ map Var vars)
+ expr = Case (Var pv) (mkWildId prod_ty) res_ty
+ [(DataAlt prod_dc, vars, res)]
+
+ return (pv, expr)
+
+ un_sum scrut [(var, expr)] = Let (NonRec var scrut) expr
+ un_sum scrut alts
+ = Case scrut (mkWildId repr_type) res_ty
+ $ zipWith mk_alt sum_data_cons alts
+
+ mk_alt sum_dc (var, expr) = (DataAlt sum_dc, [var], expr)
+
+
+buildToArrPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr
+buildToArrPRepr _ vect_tc prepr_tc arr_tc
+ = do
+ arg_ty <- mkPArrayType el_ty
+ rep_tys <- mapM (mapM mkPArrayType) rep_el_tys
+
+ arg <- newLocalVar FSLIT("xs") arg_ty
+ bndrss <- mapM (mapM (newLocalVar FSLIT("ys"))) rep_tys
+ len <- newLocalVar FSLIT("len") intPrimTy
+ sel <- newLocalVar FSLIT("sel") =<< mkPArrayType intTy
+
+ let add_sel xs | has_selector = sel : xs
+ | otherwise = xs
+
+ all_bndrs = len : add_sel (concat bndrss)
+
+ res <- parrayCoerce prepr_tc var_tys
+ =<< mkToArrPRepr (Var len) (Var sel) (map (map Var) bndrss)
+ res_ty <- mkPArrayType =<< mkPReprType el_ty
+
+ return . Lam arg
+ $ Case (unwrapFamInstScrut arr_tc var_tys (Var arg))
+ (mkWildId (mkTyConApp arr_tc var_tys))
+ res_ty
+ [(DataAlt arr_dc, all_bndrs, res)]
+ where
+ var_tys = mkTyVarTys $ tyConTyVars vect_tc
+ el_ty = mkTyConApp vect_tc var_tys
+ data_cons = tyConDataCons vect_tc
+ rep_el_tys = map dataConRepArgTys data_cons
+
+ [arr_dc] = tyConDataCons arr_tc
+
+ has_selector | [_] <- data_cons = False
+ | otherwise = True
+
+buildFromArrPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr
+buildFromArrPRepr _ vect_tc prepr_tc arr_tc
+ = mkFromArrPRepr undefined undefined undefined undefined undefined undefined
+
+buildPRDict :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr
+buildPRDict (TyConRepr {
+ repr_tys = repr_tys
+ , repr_prod_tycons = prod_tycons
+ , repr_prod_tys = prod_tys
+ , repr_sum_tycon = repr_sum_tycon
+ })
+ vect_tc prepr_tc _
+ = do
+ prs <- mapM (mapM mkPR) repr_tys
+ prod_prs <- sequence $ zipWith3 mk_prod_pr prod_tycons repr_tys prs
+ sum_pr <- mk_sum_pr prod_prs
+ prCoerce prepr_tc var_tys sum_pr
+ where
+ var_tys = mkTyVarTys $ tyConTyVars vect_tc
+
+ Just sum_tycon = repr_sum_tycon
+
+ mk_prod_pr _ _ [] = prDFunOfTyCon unitTyCon
+ mk_prod_pr _ _ [pr] = return pr
+ mk_prod_pr (Just tc) tys prs
+ = do
+ dfun <- prDFunOfTyCon tc
+ return $ dfun `mkTyApps` tys `mkApps` prs
+
+ mk_sum_pr [pr] = return pr
+ mk_sum_pr prs
+ = do
+ dfun <- prDFunOfTyCon sum_tycon
+ return $ dfun `mkTyApps` prod_tys `mkApps` prs
+
buildPArrayTyCon :: TyCon -> TyCon -> VM TyCon
buildPArrayTyCon orig_tc vect_tc = fixV $ \repr_tc ->
do
name' <- cloneName mkPArrayTyConOcc orig_name
- parent <- buildPArrayParentInfo orig_name vect_tc repr_tc
rhs <- buildPArrayTyConRhs orig_name vect_tc repr_tc
-
- return $ mkAlgTyCon name'
- kind
- tyvars
- [] -- no stupid theta
- rhs
- [] -- no selector ids
- parent
- rec_flag -- FIXME: is this ok?
- False -- FIXME: no generics
- False -- not GADT syntax
+ parray <- builtin parrayTyCon
+
+ liftDs $ buildAlgTyCon name'
+ tyvars
+ [] -- no stupid theta
+ rhs
+ rec_flag -- FIXME: is this ok?
+ False -- FIXME: no generics
+ False -- not GADT syntax
+ (Just $ mk_fam_inst parray vect_tc)
where
orig_name = tyConName orig_tc
- name = tyConName vect_tc
- kind = tyConKind vect_tc
tyvars = tyConTyVars vect_tc
rec_flag = boolToRecFlag (isRecursiveTyCon vect_tc)
-buildPArrayParentInfo :: Name -> TyCon -> TyCon -> VM TyConParent
-buildPArrayParentInfo orig_name vect_tc repr_tc
- = do
- parray_tc <- builtin parrayTyCon
- co_name <- cloneName mkInstTyCoOcc (tyConName repr_tc)
-
- let inst_tys = [mkTyConApp vect_tc (map mkTyVarTy tyvars)]
-
- return . FamilyTyCon parray_tc inst_tys
- $ mkFamInstCoercion co_name
- tyvars
- parray_tc
- inst_tys
- repr_tc
- where
- tyvars = tyConTyVars vect_tc
-
buildPArrayTyConRhs :: Name -> TyCon -> TyCon -> VM AlgTyConRhs
buildPArrayTyConRhs orig_name vect_tc repr_tc
= do
dc_name <- cloneName mkPArrayDataConOcc orig_name
shape <- tyConShape vect_tc
repr_tys <- mapM mkPArrayType types
- wrk_name <- cloneName mkDataConWorkerOcc dc_name
- wrp_name <- cloneName mkDataConWrapperOcc dc_name
-
- let ids = mkDataConIds wrp_name wrk_name data_con
- data_con = mkDataCon dc_name
- False
- (shapeStrictness shape ++ map (const NotMarkedStrict) repr_tys)
- []
- (tyConTyVars vect_tc)
- []
- []
- []
- (shapeReprTys shape ++ repr_tys)
- repr_tc
- []
- ids
-
- return data_con
+
+ liftDs $ buildDataCon dc_name
+ False -- not infix
+ (shapeStrictness shape ++ map (const NotMarkedStrict) repr_tys)
+ [] -- no field labels
+ (tyConTyVars vect_tc)
+ [] -- no existentials
+ [] -- no eq spec
+ [] -- no context
+ (shapeReprTys shape ++ repr_tys)
+ repr_tc
where
types = [ty | dc <- tyConDataCons vect_tc
, ty <- dataConRepArgTys dc]
return [e]
}
-buildTyConBindings :: TyCon -> TyCon -> TyCon -> Var -> VM [(Var, CoreExpr)]
-buildTyConBindings orig_tc vect_tc arr_tc dfun
+buildTyConBindings :: TyCon -> TyCon -> TyCon -> TyCon -> Var
+ -> VM [(Var, CoreExpr)]
+buildTyConBindings orig_tc vect_tc prepr_tc arr_tc dfun
= do
shape <- tyConShape vect_tc
+ repr <- mkTyConRepr vect_tc
sequence_ (zipWith4 (vectDataConWorker shape vect_tc arr_tc arr_dc)
orig_dcs
vect_dcs
(inits repr_tys)
(tails repr_tys))
- dict <- buildPADict shape vect_tc arr_tc dfun
+ dict <- buildPADict repr vect_tc prepr_tc arr_tc dfun
binds <- takeHoisted
return $ (dfun, dict) : binds
where
args <- mapM (newLocalVar FSLIT("xs")) arr_tys
shapes <- shapeReplicate shape
(Var len)
- (mkIntLitInt $ dataConTag vect_dc)
+ (mkDataConTag vect_dc)
empty_pre <- mapM emptyPA (concat pre)
empty_post <- mapM emptyPA (concat post)
++ map Var args
++ empty_post
-buildPADict :: Shape -> TyCon -> TyCon -> Var -> VM CoreExpr
-buildPADict shape vect_tc arr_tc dfun
+buildPADict :: TyConRepr -> TyCon -> TyCon -> TyCon -> Var -> VM CoreExpr
+buildPADict repr vect_tc prepr_tc arr_tc dfun
= polyAbstract tvs $ \abstract ->
do
- meth_binds <- mapM (mk_method shape) paMethods
+ meth_binds <- mapM (mk_method repr) paMethods
let meth_exprs = map (Var . fst) meth_binds
pa_dc <- builtin paDataCon
tvs = tyConTyVars arr_tc
arg_tys = mkTyVarTys tvs
- mk_method shape (name, build)
+ mk_method repr (name, build)
= localV
$ do
- body <- build shape vect_tc arr_tc
+ body <- build repr vect_tc prepr_tc arr_tc
var <- newLocalVar name (exprType body)
return (var, mkInlineMe body)
-paMethods = [(FSLIT("lengthPA"), buildLengthPA),
- (FSLIT("replicatePA"), buildReplicatePA)]
-
-buildLengthPA :: Shape -> TyCon -> TyCon -> VM CoreExpr
-buildLengthPA shape vect_tc arr_tc
- = do
- parr_ty <- mkPArrayType (mkTyConApp vect_tc arg_tys)
- arg <- newLocalVar FSLIT("xs") parr_ty
- shapes <- mapM (newLocalVar FSLIT("sh")) shape_tys
- wilds <- mapM newDummyVar repr_tys
- let scrut = unwrapFamInstScrut arr_tc arg_tys (Var arg)
- scrut_ty = exprType scrut
-
- body <- shapeLength shape (map Var shapes)
-
- return . Lam arg
- $ Case scrut (mkWildId scrut_ty) intPrimTy
- [(DataAlt repr_dc, shapes ++ wilds, body)]
- where
- arg_tys = mkTyVarTys $ tyConTyVars arr_tc
- [repr_dc] = tyConDataCons arr_tc
-
- shape_tys = shapeReprTys shape
- repr_tys = drop (length shape_tys) (dataConRepArgTys repr_dc)
-
--- data T = C0 t1 ... tm
--- ...
--- Ck u1 ... un
---
--- data [:T:] = A ![:Int:] [:t1:] ... [:un:]
---
--- replicatePA :: Int# -> T -> [:T:]
--- replicatePA n# t
--- = let c = case t of
--- C0 _ ... _ -> 0
--- ...
--- Ck _ ... _ -> k
---
--- xs1 = case t of
--- C0 x1 _ ... _ -> replicatePA @t1 n# x1
--- _ -> emptyPA @t1
---
--- ...
---
--- ysn = case t of
--- Ck _ ... _ yn -> replicatePA @un n# yn
--- _ -> emptyPA @un
--- in
--- A (replicatePA @Int n# c) xs1 ... ysn
---
---
-
-buildReplicatePA :: Shape -> TyCon -> TyCon -> VM CoreExpr
-buildReplicatePA shape vect_tc arr_tc
- = do
- len_var <- newLocalVar FSLIT("n") intPrimTy
- val_var <- newLocalVar FSLIT("x") val_ty
-
- let len = Var len_var
- val = Var val_var
-
- shape_reprs <- shapeReplicate shape len (ctr_num val)
- reprs <- liftM concat $ mapM (mk_comp_arrs len val) vect_dcs
-
- return . mkLams [len_var, val_var]
- . wrapFamInstBody arr_tc arg_tys
- $ mkConApp arr_dc (map Type arg_tys ++ shape_reprs ++ reprs)
- where
- arg_tys = mkTyVarTys (tyConTyVars arr_tc)
- val_ty = mkTyConApp vect_tc arg_tys
- wild = mkWildId val_ty
- vect_dcs = tyConDataCons vect_tc
- [arr_dc] = tyConDataCons arr_tc
-
- ctr_num val = Case val wild intTy (zipWith ctr_num_alt vect_dcs [0..])
- ctr_num_alt dc i = (DataAlt dc, map mkWildId (dataConRepArgTys dc),
- mkConApp intDataCon [mkIntLitInt i])
-
-
- mk_comp_arrs len val dc = let tys = dataConRepArgTys dc
- wilds = map mkWildId tys
- in
- sequence (zipWith3 (mk_comp_arr len val dc)
- tys (inits wilds) (tails wilds))
-
- mk_comp_arr len val dc ty pre (_:post)
- = do
- var <- newLocalVar FSLIT("x") ty
- rep <- replicatePA len (Var var)
- empty <- emptyPA ty
- arr_ty <- mkPArrayType ty
-
- return $ Case val wild arr_ty
- [(DEFAULT, [], empty), (DataAlt dc, pre ++ (var : post), rep)]
+paMethods = [(FSLIT("toPRepr"), buildToPRepr),
+ (FSLIT("fromPRepr"), buildFromPRepr),
+ (FSLIT("toArrPRepr"), buildToArrPRepr),
+ (FSLIT("fromArrPRepr"), buildFromArrPRepr),
+ (FSLIT("dictPRepr"), buildPRDict)]
-- | Split the given tycons into two sets depending on whether they have to be
-- converted (first list) or not (second list). The first argument contains