+{-# OPTIONS -w #-}
+-- The above warning supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
module VectType ( vectTyCon, vectType, vectTypeEnv,
PAInstance, buildPADict )
where
import Id ( mkWildId )
import Name ( Name, getOccName )
import NameEnv
-import TysWiredIn ( unitTy, unitTyCon, intTy, intDataCon, unitDataConId )
+import TysWiredIn
import TysPrim ( intPrimTy )
import Unique
, void_bottom :: CoreExpr
}
+ | EnumRepr {
+ enum_tycon :: TyCon
+ , enum_data_con :: DataCon
+ , enum_arr_tycon :: TyCon
+ , enum_arr_data_con :: DataCon
+ }
+
voidRepr :: VM Repr
voidRepr
= do
, void_bottom = Var var
}
+enumRepr :: VM Repr
+enumRepr
+ = do
+ (arr_tycon, _) <- parrayReprTyCon intTy
+ let [arr_data_con] = tyConDataCons arr_tycon
+
+ return $ EnumRepr {
+ enum_tycon = tycon
+ , enum_data_con = data_con
+ , enum_arr_tycon = arr_tycon
+ , enum_arr_data_con = arr_data_con
+ }
+ where
+ tycon = intTyCon
+ data_con = intDataCon
+
unboxedProductRepr :: [Type] -> VM Repr
unboxedProductRepr [] = voidRepr
unboxedProductRepr [ty] = return $ IdRepr ty
= mkTyConApp tycon (map reprType reprs)
reprType (IdRepr ty) = ty
reprType (VoidRepr { void_tycon = tycon }) = mkTyConApp tycon []
+reprType (EnumRepr { enum_tycon = tycon }) = mkTyConApp tycon []
arrReprType :: Repr -> VM Type
arrReprType = mkPArrayType . reprType
arrShapeTys (ProdRepr {}) = return [intPrimTy]
arrShapeTys (IdRepr _) = return []
arrShapeTys (VoidRepr {}) = return [intPrimTy]
+arrShapeTys (EnumRepr {}) = return [intPrimTy]
arrShapeVars :: Repr -> VM [Var]
arrShapeVars repr = mapM (newLocalVar FSLIT("sh")) =<< arrShapeTys repr
return [len, Var rep `mkApps` [len, tag], Var up `App` len]
replicateShape (IdRepr _) _ _ = return []
replicateShape (VoidRepr {}) len _ = return [len]
+replicateShape (EnumRepr {}) len _ = return [len]
emptyArrRepr :: Repr -> VM [CoreExpr]
emptyArrRepr (SumRepr { sum_components = prods })
= liftM singleton $ emptyPA ty
emptyArrRepr (VoidRepr { void_tycon = tycon })
= liftM singleton $ emptyPA (mkTyConApp tycon [])
+emptyArrRepr (EnumRepr { enum_tycon = tycon })
+ = liftM singleton $ emptyPA (mkTyConApp tycon [])
arrReprTys :: Repr -> VM [Type]
arrReprTys (SumRepr { sum_components = reprs })
= liftM singleton $ mkPArrayType ty
arrReprTys (VoidRepr { void_tycon = tycon })
= liftM singleton $ mkPArrayType (mkTyConApp tycon [])
+arrReprTys (EnumRepr {})
+ = liftM singleton $ mkPArrayType intPrimTy
arrReprTys' :: Repr -> VM [[Type]]
arrReprTys' (SumRepr { sum_components = reprs })
mkRepr :: TyCon -> VM Repr
mkRepr vect_tc
- = sumRepr =<< mapM unboxedProductRepr rep_tys
+ | [tys] <- rep_tys = boxedProductRepr tys
+ | all null rep_tys = enumRepr
+ | otherwise = sumRepr =<< mapM unboxedProductRepr rep_tys
where
rep_tys = map dataConRepArgTys $ tyConDataCons vect_tc
, sum_tycon = tycon })
expr
= do
- (vars, bodies) <- mapAndUnzipM prod_alt prods
+ (vars, bodies) <- mapAndUnzipM to_unboxed prods
return . Case expr (mkWildId (exprType expr)) res_ty
$ zipWith4 mk_alt cons vars (tyConDataCons tycon) bodies
where
ty_args = map (Type . reprType) prods
+ to_repr (EnumRepr { enum_data_con = data_con }) expr
+ = return . Case expr (mkWildId (exprType expr)) res_ty
+ $ map mk_alt cons
+ where
+ mk_alt con = (DataAlt con, [], mkConApp data_con [mkDataConTag con])
+
to_repr prod expr
= do
- (vars, body) <- prod_alt prod
+ (vars, body) <- to_unboxed prod
return $ Case expr (mkWildId (exprType expr)) res_ty
[(DataAlt con, vars, body)]
- prod_alt (ProdRepr { prod_components = tys
- , prod_data_con = data_con })
+ to_unboxed (ProdRepr { prod_components = tys
+ , prod_data_con = data_con })
= do
vars <- mapM (newLocalVar FSLIT("r")) tys
return (vars, mkConApp data_con (map Type tys ++ map Var vars))
- prod_alt (IdRepr ty)
+ to_unboxed (IdRepr ty)
= do
var <- newLocalVar FSLIT("y") ty
return ([var], Var var)
- prod_alt (VoidRepr { void_bottom = bottom })
+ to_unboxed (VoidRepr { void_bottom = bottom })
= return ([], bottom)
expr
= do
vars <- mapM (newLocalVar FSLIT("x")) (map reprType prods)
- bodies <- sequence . zipWith3 from_prod prods cons
+ bodies <- sequence . zipWith3 from_unboxed prods cons
$ map Var vars
return . Case expr (mkWildId (reprType repr)) res_ty
$ zipWith3 sum_alt (tyConDataCons tycon) vars bodies
where
sum_alt data_con var body = (DataAlt data_con, [var], body)
- from_repr repr expr = from_prod repr con expr
+ from_repr repr@(EnumRepr { enum_data_con = data_con }) expr
+ = do
+ var <- newLocalVar FSLIT("n") intPrimTy
- from_prod prod@(ProdRepr { prod_components = tys
- , prod_data_con = data_con })
+ let res = Case (Var var) (mkWildId intPrimTy) res_ty
+ $ (DEFAULT, [], error_expr)
+ : zipWith mk_alt (tyConDataCons vect_tc) cons
+
+ return $ Case expr (mkWildId (reprType repr)) res_ty
+ [(DataAlt data_con, [var], res)]
+ where
+ mk_alt data_con con = (LitAlt (mkDataConTagLit data_con), [], con)
+
+ error_expr = mkRuntimeErrorApp rUNTIME_ERROR_ID res_ty
+ . showSDoc
+ $ sep [text "Invalid NDP representation of", ppr vect_tc]
+
+ from_repr repr expr = from_unboxed repr con expr
+
+ from_unboxed prod@(ProdRepr { prod_components = tys
+ , prod_data_con = data_con })
con
expr
= do
return $ Case expr (mkWildId (reprType prod)) res_ty
[(DataAlt data_con, vars, con `mkVarApps` vars)]
- from_prod (IdRepr _) con expr
+ from_unboxed (IdRepr _) con expr
= return $ con `App` expr
- from_prod (VoidRepr {}) con expr
+ from_unboxed (VoidRepr {}) con expr
= return con
buildToArrPRepr :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr
. mkConApp data_con
$ map Type tys ++ map Var (len_var : repr_vars)
+ to_repr [len_var]
+ [[repr_var]]
+ (EnumRepr { enum_arr_tycon = tycon
+ , enum_arr_data_con = data_con })
+ = return . wrapFamInstBody tycon []
+ $ mkConApp data_con [Var len_var, Var repr_var]
+
to_prod repr_vars@(r : _)
- (ProdRepr { prod_components = tys
+ (ProdRepr { prod_components = tys@(ty : _)
, prod_arr_tycon = tycon
, prod_arr_data_con = data_con })
= do
- len <- lengthPA (Var r)
+ len <- lengthPA ty (Var r)
return . wrapFamInstBody tycon tys
. mkConApp data_con
$ map Type tys ++ len : map Var repr_vars
return $ Case scrut (mkWildId scrut_ty) res_ty
[(DataAlt data_con, shape_vars ++ repr_vars, body)]
+ from_prod (EnumRepr { enum_arr_tycon = tycon
+ , enum_arr_data_con = data_con })
+ expr
+ [len_var]
+ [repr_var]
+ res_ty
+ body
+ = let scrut = unwrapFamInstScrut tycon [] expr
+ scrut_ty = mkTyConApp tycon []
+ in
+ return $ Case scrut (mkWildId scrut_ty) res_ty
+ [(DataAlt data_con, [len_var, repr_var], body)]
+
from_prod (IdRepr ty)
expr
shape_vars
dfun <- prDFunOfTyCon tycon
return $ dfun `mkTyApps` map reprType prods `mkApps` prs
+buildPRDictRepr (EnumRepr { enum_tycon = tycon })
+ = prDFunOfTyCon tycon
+
buildPRDict :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr
buildPRDict repr vect_tc prepr_tc _
= do
projects / ghc-hetmet.git / blobdiff