-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
-- for details
-module VectType ( vectTyCon, vectType, vectTypeEnv,
+module VectType ( vectTyCon, vectAndLiftType, vectType, vectTypeEnv,
mkRepr, arrShapeTys, arrShapeVars, arrSelector,
PAInstance, buildPADict,
fromVect )
where
-#include "HsVersions.h"
-
import VectMonad
import VectUtils
import VectCore
import OccName
import MkId
import BasicTypes ( StrictnessMark(..), OverlapFlag(..), boolToRecFlag )
-import Var ( Var )
+import Var ( Var, TyVar )
import Id ( mkWildId )
import Name ( Name, getOccName )
import NameEnv
import Digraph ( SCC(..), stronglyConnComp )
import Outputable
+import FastString
import Control.Monad ( liftM, liftM2, zipWithM, zipWithM_, mapAndUnzipM )
import Data.List ( inits, tails, zipWith4, zipWith5 )
-- FIXME: just for now
Nothing -> pprTrace "ccTyCon:" (ppr tc) $ return tc
+vectAndLiftType :: Type -> VM (Type, Type)
+vectAndLiftType ty | Just ty' <- coreView ty = vectAndLiftType ty'
+vectAndLiftType ty
+ = do
+ mdicts <- mapM paDictArgType tyvars
+ let dicts = [dict | Just dict <- mdicts]
+ vmono_ty <- vectType mono_ty
+ lmono_ty <- mkPArrayType vmono_ty
+ return (abstractType tyvars dicts vmono_ty,
+ abstractType tyvars dicts lmono_ty)
+ where
+ (tyvars, mono_ty) = splitForAllTys ty
+
+
vectType :: Type -> VM Type
vectType ty | Just ty' <- coreView ty = vectType ty'
vectType (TyVarTy tv) = return $ TyVarTy tv
= do
mdicts <- mapM paDictArgType tyvars
mono_ty' <- vectType mono_ty
- return $ tyvars `mkForAllTys` ([dict | Just dict <- mdicts] `mkFunTys` mono_ty')
+ return $ abstractType tyvars [dict | Just dict <- mdicts] mono_ty'
where
(tyvars, mono_ty) = splitForAllTys ty
vectAndBoxType :: Type -> VM Type
vectAndBoxType ty = vectType ty >>= boxType
+abstractType :: [TyVar] -> [Type] -> Type -> Type
+abstractType tyvars dicts = mkForAllTys tyvars . mkFunTys dicts
+
-- ----------------------------------------------------------------------------
-- Boxing
arrShapeVars :: Repr -> VM [Var]
-arrShapeVars repr = mapM (newLocalVar FSLIT("sh")) =<< arrShapeTys repr
+arrShapeVars repr = mapM (newLocalVar (fsLit "sh")) =<< arrShapeTys repr
replicateShape :: Repr -> CoreExpr -> CoreExpr -> VM [CoreExpr]
replicateShape (ProdRepr {}) len _ = return [len]
arrReprVars :: Repr -> VM [[Var]]
arrReprVars repr
- = mapM (mapM (newLocalVar FSLIT("rs"))) =<< arrReprTys' repr
+ = mapM (mapM (newLocalVar (fsLit "rs"))) =<< arrReprTys' repr
mkRepr :: TyCon -> VM Repr
mkRepr vect_tc
buildToPRepr :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr
buildToPRepr repr vect_tc prepr_tc _
= do
- arg <- newLocalVar FSLIT("x") arg_ty
+ arg <- newLocalVar (fsLit "x") arg_ty
result <- to_repr repr (Var arg)
return . Lam arg
to_unboxed (ProdRepr { prod_components = tys
, prod_data_con = data_con })
= do
- vars <- mapM (newLocalVar FSLIT("r")) tys
+ vars <- mapM (newLocalVar (fsLit "r")) tys
return (vars, mkConApp data_con (map Type tys ++ map Var vars))
to_unboxed (IdRepr ty)
= do
- var <- newLocalVar FSLIT("y") ty
+ var <- newLocalVar (fsLit "y") ty
return ([var], Var var)
to_unboxed (VoidRepr { void_bottom = bottom })
buildFromPRepr repr vect_tc prepr_tc _
= do
arg_ty <- mkPReprType res_ty
- arg <- newLocalVar FSLIT("x") arg_ty
+ arg <- newLocalVar (fsLit "x") arg_ty
liftM (Lam arg)
. from_repr repr
, sum_tycon = tycon })
expr
= do
- vars <- mapM (newLocalVar FSLIT("x")) (map reprType prods)
+ vars <- mapM (newLocalVar (fsLit "x")) (map reprType prods)
bodies <- sequence . zipWith3 from_unboxed prods cons
$ map Var vars
return . Case expr (mkWildId (reprType repr)) res_ty
from_repr repr@(EnumRepr { enum_data_con = data_con }) expr
= do
- var <- newLocalVar FSLIT("n") intPrimTy
+ var <- newLocalVar (fsLit "n") intPrimTy
let res = Case (Var var) (mkWildId intPrimTy) res_ty
$ (DEFAULT, [], error_expr)
con
expr
= do
- vars <- mapM (newLocalVar FSLIT("y")) tys
+ vars <- mapM (newLocalVar (fsLit "y")) tys
return $ Case expr (mkWildId (reprType prod)) res_ty
[(DataAlt data_con, vars, con `mkVarApps` vars)]
buildToArrPRepr repr vect_tc prepr_tc arr_tc
= do
arg_ty <- mkPArrayType el_ty
- arg <- newLocalVar FSLIT("xs") arg_ty
+ arg <- newLocalVar (fsLit "xs") arg_ty
res_ty <- mkPArrayType (reprType repr)
buildFromArrPRepr repr vect_tc prepr_tc arr_tc
= do
arg_ty <- mkPArrayType =<< mkPReprType el_ty
- arg <- newLocalVar FSLIT("xs") arg_ty
+ arg <- newLocalVar (fsLit "xs") arg_ty
res_ty <- mkPArrayType el_ty
res_ty
body
= do
- vars <- mapM (newLocalVar FSLIT("xs")) =<< mapM arrReprType prods
+ vars <- mapM (newLocalVar (fsLit "xs")) =<< mapM arrReprType prods
result <- go prods repr_vars vars body
let scrut = unwrapFamInstScrut tycon ty_args expr
go [] [] [] body = return body
go (prod : prods) (repr_vars : rss) (var : vars) body
= do
- shape_vars <- mapM (newLocalVar FSLIT("s")) =<< arrShapeTys prod
+ shape_vars <- mapM (newLocalVar (fsLit "s")) =<< arrShapeTys prod
from_prod prod (Var var) shape_vars repr_vars res_ty
=<< go prods rss vars body
lift_data_con tys pre_reprs post_reprs tag
= do
len <- builtin liftingContext
- args <- mapM (newLocalVar FSLIT("xs"))
+ args <- mapM (newLocalVar (fsLit "xs"))
=<< mapM mkPArrayType tys
shape <- replicateShape repr (Var len) tag
var <- newLocalVar name (exprType body)
return (var, mkInlineMe body)
-paMethods = [(FSLIT("toPRepr"), buildToPRepr),
- (FSLIT("fromPRepr"), buildFromPRepr),
- (FSLIT("toArrPRepr"), buildToArrPRepr),
- (FSLIT("fromArrPRepr"), buildFromArrPRepr),
- (FSLIT("dictPRepr"), buildPRDict)]
+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
fromVect ty expr | Just ty' <- coreView ty = fromVect ty' expr
fromVect (FunTy arg_ty res_ty) expr
= do
- arg <- newLocalVar FSLIT("x") arg_ty
+ arg <- newLocalVar (fsLit "x") arg_ty
varg <- toVect arg_ty (Var arg)
varg_ty <- vectType arg_ty
vres_ty <- vectType res_ty
projects / ghc-hetmet.git / blobdiff