module VectBuiltIn (
Builtins(..), sumTyCon, prodTyCon,
- combinePAVar,
+ combinePAVar, scalarZip, closureCtrFun,
initBuiltins, initBuiltinVars, initBuiltinTyCons, initBuiltinDataCons,
initBuiltinPAs, initBuiltinPRs,
- initBuiltinBoxedTyCons,
+ initBuiltinBoxedTyCons, initBuiltinScalars,
primMethod, primPArray
) where
import Module
import DataCon ( DataCon, dataConName, dataConWorkId )
import TyCon ( TyCon, tyConName, tyConDataCons )
+import Class ( Class )
import Var ( Var )
import Id ( mkSysLocal )
import Name ( Name, getOccString )
doubleTyCon, doubleTyConName,
boolTyCon, boolTyConName, trueDataCon, falseDataCon,
parrTyConName )
-import PrelNames ( gHC_PARR )
+import PrelNames ( word8TyConName, gHC_PARR )
import BasicTypes ( Boxity(..) )
import FastString
import Control.Monad ( liftM, zipWithM )
import Data.List ( unzip4 )
-mAX_NDP_PROD :: Int
-mAX_NDP_PROD = 5
+mAX_DPH_PROD :: Int
+mAX_DPH_PROD = 5
-mAX_NDP_SUM :: Int
-mAX_NDP_SUM = 3
+mAX_DPH_SUM :: Int
+mAX_DPH_SUM = 3
-mAX_NDP_COMBINE :: Int
-mAX_NDP_COMBINE = 2
+mAX_DPH_COMBINE :: Int
+mAX_DPH_COMBINE = 2
+
+mAX_DPH_SCALAR_ARGS :: Int
+mAX_DPH_SCALAR_ARGS = 3
data Modules = Modules {
dph_PArray :: Module
, dph_Unboxed :: Module
, dph_Instances :: Module
, dph_Combinators :: Module
+ , dph_Scalar :: Module
, dph_Prelude_PArr :: Module
, dph_Prelude_Int :: Module
+ , dph_Prelude_Word8 :: Module
, dph_Prelude_Double :: Module
, dph_Prelude_Bool :: Module
, dph_Prelude_Tuple :: Module
, dph_Unboxed = mk (fsLit "Data.Array.Parallel.Lifted.Unboxed")
, dph_Instances = mk (fsLit "Data.Array.Parallel.Lifted.Instances")
, dph_Combinators = mk (fsLit "Data.Array.Parallel.Lifted.Combinators")
+ , dph_Scalar = mk (fsLit "Data.Array.Parallel.Lifted.Scalar")
, dph_Prelude_PArr = mk (fsLit "Data.Array.Parallel.Prelude.Base.PArr")
, dph_Prelude_Int = mk (fsLit "Data.Array.Parallel.Prelude.Base.Int")
+ , dph_Prelude_Word8 = mk (fsLit "Data.Array.Parallel.Prelude.Base.Word8")
, dph_Prelude_Double = mk (fsLit "Data.Array.Parallel.Prelude.Base.Double")
, dph_Prelude_Bool = mk (fsLit "Data.Array.Parallel.Prelude.Base.Bool")
, dph_Prelude_Tuple = mk (fsLit "Data.Array.Parallel.Prelude.Base.Tuple")
, emptyPAVar :: Var
, packPAVar :: Var
, combinePAVars :: Array Int Var
+ , scalarClass :: Class
+ , scalarZips :: Array Int Var
+ , closureCtrFuns :: Array Int Var
, liftingContext :: Var
}
sumTyCon :: Int -> Builtins -> TyCon
sumTyCon n bi
- | n >= 2 && n <= mAX_NDP_SUM = sumTyCons bi ! n
+ | n >= 2 && n <= mAX_DPH_SUM = sumTyCons bi ! n
| otherwise = pprPanic "sumTyCon" (ppr n)
prodTyCon :: Int -> Builtins -> TyCon
prodTyCon n bi
| n == 1 = wrapTyCon bi
- | n >= 0 && n <= mAX_NDP_PROD = tupleTyCon Boxed n
+ | n >= 0 && n <= mAX_DPH_PROD = tupleTyCon Boxed n
| otherwise = pprPanic "prodTyCon" (ppr n)
combinePAVar :: Int -> Builtins -> Var
combinePAVar n bi
- | n >= 2 && n <= mAX_NDP_COMBINE = combinePAVars bi ! n
+ | n >= 2 && n <= mAX_DPH_COMBINE = combinePAVars bi ! n
| otherwise = pprPanic "combinePAVar" (ppr n)
+scalarZip :: Int -> Builtins -> Var
+scalarZip n bi
+ | n >= 1 && n <= mAX_DPH_SCALAR_ARGS = scalarZips bi ! n
+ | otherwise = pprPanic "scalarZip" (ppr n)
+
+closureCtrFun :: Int -> Builtins -> Var
+closureCtrFun n bi
+ | n >= 1 && n <= mAX_DPH_SCALAR_ARGS = closureCtrFuns bi ! n
+ | otherwise = pprPanic "closureCtrFun" (ppr n)
+
initBuiltins :: PackageId -> DsM Builtins
initBuiltins pkg
= do
wrapTyCon <- externalTyCon dph_Repr (fsLit "Wrap")
enumerationTyCon <- externalTyCon dph_Repr (fsLit "Enumeration")
sum_tcs <- mapM (externalTyCon dph_Repr)
- [mkFastString ("Sum" ++ show i) | i <- [2..mAX_NDP_SUM]]
+ [mkFastString ("Sum" ++ show i) | i <- [2..mAX_DPH_SUM]]
- let sumTyCons = listArray (2, mAX_NDP_SUM) sum_tcs
+ let sumTyCons = listArray (2, mAX_DPH_SUM) sum_tcs
voidVar <- externalVar dph_Repr (fsLit "void")
mkPRVar <- externalVar dph_PArray (fsLit "mkPR")
combines <- mapM (externalVar dph_PArray)
[mkFastString ("combine" ++ show i ++ "PA#")
- | i <- [2..mAX_NDP_COMBINE]]
- let combinePAVars = listArray (2, mAX_NDP_COMBINE) combines
+ | i <- [2..mAX_DPH_COMBINE]]
+ let combinePAVars = listArray (2, mAX_DPH_COMBINE) combines
+
+ scalarClass <- externalClass dph_Scalar (fsLit "Scalar")
+ scalar_map <- externalVar dph_Scalar (fsLit "scalar_map")
+ scalar_zip2 <- externalVar dph_Scalar (fsLit "scalar_zipWith")
+ scalar_zips <- mapM (externalVar dph_Scalar)
+ [mkFastString ("scalar_zipWith" ++ show i)
+ | i <- [3 .. mAX_DPH_SCALAR_ARGS]]
+ let scalarZips = listArray (1, mAX_DPH_SCALAR_ARGS)
+ (scalar_map : scalar_zip2 : scalar_zips)
+ closures <- mapM (externalVar dph_Closure)
+ [mkFastString ("closure" ++ show i)
+ | i <- [1 .. mAX_DPH_SCALAR_ARGS]]
+ let closureCtrFuns = listArray (1, mAX_DPH_COMBINE) closures
liftingContext <- liftM (\u -> mkSysLocal (fsLit "lc") u intPrimTy)
newUnique
, emptyPAVar = emptyPAVar
, packPAVar = packPAVar
, combinePAVars = combinePAVars
+ , scalarClass = scalarClass
+ , scalarZips = scalarZips
+ , closureCtrFuns = closureCtrFuns
, liftingContext = liftingContext
}
where
, dph_Repr = dph_Repr
, dph_Closure = dph_Closure
, dph_Unboxed = dph_Unboxed
+ , dph_Scalar = dph_Scalar
})
= dph_Modules pkg
initBuiltinVars :: Builtins -> DsM [(Var, Var)]
-initBuiltinVars (Builtins { dphModules = modules })
+initBuiltinVars (Builtins { dphModules = mods })
= do
- uvars <- zipWithM externalVar (map ($ modules) umods) ufs
- vvars <- zipWithM externalVar (map ($ modules) vmods) vfs
- cvars <- zipWithM externalVar (map ($ modules) cmods) cfs
+ uvars <- zipWithM externalVar umods ufs
+ vvars <- zipWithM externalVar vmods vfs
+ cvars <- zipWithM externalVar cmods cfs
return $ [(v,v) | v <- map dataConWorkId defaultDataConWorkers]
++ zip (map dataConWorkId cons) cvars
++ zip uvars vvars
where
- (umods, ufs, vmods, vfs) = unzip4 preludeVars
+ (umods, ufs, vmods, vfs) = unzip4 (preludeVars mods)
- (cons, cmods, cfs) = unzip3 preludeDataCons
+ (cons, cmods, cfs) = unzip3 (preludeDataCons mods)
defaultDataConWorkers :: [DataCon]
defaultDataConWorkers = [trueDataCon, falseDataCon, unitDataCon]
-preludeDataCons :: [(DataCon, Modules -> Module, FastString)]
-preludeDataCons
+preludeDataCons :: Modules -> [(DataCon, Module, FastString)]
+preludeDataCons (Modules { dph_Prelude_Tuple = dph_Prelude_Tuple })
= [mk_tup n dph_Prelude_Tuple (mkFastString $ "tup" ++ show n) | n <- [2..3]]
where
mk_tup n mod name = (tupleCon Boxed n, mod, name)
-preludeVars :: [(Modules -> Module, FastString, Modules -> Module, FastString)]
-preludeVars
+preludeVars :: Modules -> [(Module, FastString, Module, FastString)]
+preludeVars (Modules { dph_Combinators = dph_Combinators
+ , dph_PArray = dph_PArray
+ , dph_Prelude_Int = dph_Prelude_Int
+ , dph_Prelude_Word8 = dph_Prelude_Word8
+ , dph_Prelude_Double = dph_Prelude_Double
+ , dph_Prelude_Bool = dph_Prelude_Bool
+ , dph_Prelude_PArr = dph_Prelude_PArr
+ })
= [
- mk (const gHC_PARR) (fsLit "mapP") dph_Combinators (fsLit "mapPA")
- , mk (const gHC_PARR) (fsLit "zipWithP") dph_Combinators (fsLit "zipWithPA")
- , mk (const gHC_PARR) (fsLit "zipP") dph_Combinators (fsLit "zipPA")
- , mk (const gHC_PARR) (fsLit "unzipP") dph_Combinators (fsLit "unzipPA")
- , mk (const gHC_PARR) (fsLit "filterP") dph_Combinators (fsLit "filterPA")
- , mk (const gHC_PARR) (fsLit "lengthP") dph_Combinators (fsLit "lengthPA")
- , mk (const gHC_PARR) (fsLit "replicateP") dph_Combinators (fsLit "replicatePA")
- , mk (const gHC_PARR) (fsLit "!:") dph_Combinators (fsLit "indexPA")
- , mk (const gHC_PARR) (fsLit "crossMapP") dph_Combinators (fsLit "crossMapPA")
- , mk (const gHC_PARR) (fsLit "singletonP") dph_Combinators (fsLit "singletonPA")
- , mk (const gHC_PARR) (fsLit "concatP") dph_Combinators (fsLit "concatPA")
- , mk (const gHC_PARR) (fsLit "+:+") dph_Combinators (fsLit "appPA")
- , mk (const gHC_PARR) (fsLit "emptyP") dph_PArray (fsLit "emptyPA")
-
- , mk dph_Prelude_Int (fsLit "plus") dph_Prelude_Int (fsLit "plusV")
- , mk dph_Prelude_Int (fsLit "minus") dph_Prelude_Int (fsLit "minusV")
- , mk dph_Prelude_Int (fsLit "mult") dph_Prelude_Int (fsLit "multV")
- , mk dph_Prelude_Int (fsLit "intDiv") dph_Prelude_Int (fsLit "intDivV")
- , mk dph_Prelude_Int (fsLit "intMod") dph_Prelude_Int (fsLit "intModV")
- , mk dph_Prelude_Int (fsLit "intSquareRoot") dph_Prelude_Int (fsLit "intSquareRootV")
- , mk dph_Prelude_Int (fsLit "intSumP") dph_Prelude_Int (fsLit "intSumPA")
- , mk dph_Prelude_Int (fsLit "enumFromToP") dph_Prelude_Int (fsLit "enumFromToPA")
- , mk dph_Prelude_Int (fsLit "upToP") dph_Prelude_Int (fsLit "upToPA")
-
- , mk dph_Prelude_Int (fsLit "eq") dph_Prelude_Int (fsLit "eqV")
- , mk dph_Prelude_Int (fsLit "neq") dph_Prelude_Int (fsLit "neqV")
- , mk dph_Prelude_Int (fsLit "le") dph_Prelude_Int (fsLit "leV")
- , mk dph_Prelude_Int (fsLit "lt") dph_Prelude_Int (fsLit "ltV")
- , mk dph_Prelude_Int (fsLit "ge") dph_Prelude_Int (fsLit "geV")
- , mk dph_Prelude_Int (fsLit "gt") dph_Prelude_Int (fsLit "gtV")
-
- , mk dph_Prelude_Double (fsLit "plus") dph_Prelude_Double (fsLit "plusV")
- , mk dph_Prelude_Double (fsLit "minus") dph_Prelude_Double (fsLit "minusV")
- , mk dph_Prelude_Double (fsLit "mult") dph_Prelude_Double (fsLit "multV")
- , mk dph_Prelude_Double (fsLit "divide") dph_Prelude_Double (fsLit "divideV")
- , mk dph_Prelude_Double (fsLit "squareRoot") dph_Prelude_Double (fsLit "squareRootV")
- , mk dph_Prelude_Double (fsLit "doubleSumP") dph_Prelude_Double (fsLit "doubleSumPA")
- , mk dph_Prelude_Double (fsLit "minIndexP")
- dph_Prelude_Double (fsLit "minIndexPA")
- , mk dph_Prelude_Double (fsLit "maxIndexP")
- dph_Prelude_Double (fsLit "maxIndexPA")
-
- , mk dph_Prelude_Double (fsLit "eq") dph_Prelude_Double (fsLit "eqV")
- , mk dph_Prelude_Double (fsLit "neq") dph_Prelude_Double (fsLit "neqV")
- , mk dph_Prelude_Double (fsLit "le") dph_Prelude_Double (fsLit "leV")
- , mk dph_Prelude_Double (fsLit "lt") dph_Prelude_Double (fsLit "ltV")
- , mk dph_Prelude_Double (fsLit "ge") dph_Prelude_Double (fsLit "geV")
- , mk dph_Prelude_Double (fsLit "gt") dph_Prelude_Double (fsLit "gtV")
-
- , mk dph_Prelude_Bool (fsLit "andP") dph_Prelude_Bool (fsLit "andPA")
+ mk gHC_PARR (fsLit "mapP") dph_Combinators (fsLit "mapPA")
+ , mk gHC_PARR (fsLit "zipWithP") dph_Combinators (fsLit "zipWithPA")
+ , mk gHC_PARR (fsLit "zipP") dph_Combinators (fsLit "zipPA")
+ , mk gHC_PARR (fsLit "unzipP") dph_Combinators (fsLit "unzipPA")
+ , mk gHC_PARR (fsLit "filterP") dph_Combinators (fsLit "filterPA")
+ , mk gHC_PARR (fsLit "lengthP") dph_Combinators (fsLit "lengthPA")
+ , mk gHC_PARR (fsLit "replicateP") dph_Combinators (fsLit "replicatePA")
+ , mk gHC_PARR (fsLit "!:") dph_Combinators (fsLit "indexPA")
+ , mk gHC_PARR (fsLit "crossMapP") dph_Combinators (fsLit "crossMapPA")
+ , mk gHC_PARR (fsLit "singletonP") dph_Combinators (fsLit "singletonPA")
+ , mk gHC_PARR (fsLit "concatP") dph_Combinators (fsLit "concatPA")
+ , mk gHC_PARR (fsLit "+:+") dph_Combinators (fsLit "appPA")
+ , mk gHC_PARR (fsLit "emptyP") dph_PArray (fsLit "emptyPA")
+
+ , mk' dph_Prelude_Int "div" "divV"
+ , mk' dph_Prelude_Int "mod" "modV"
+ , mk' dph_Prelude_Int "sqrt" "sqrtV"
+ , mk' dph_Prelude_Int "enumFromToP" "enumFromToPA"
+ , mk' dph_Prelude_Int "upToP" "upToPA"
+ ]
+ ++ vars_Ord dph_Prelude_Int
+ ++ vars_Num dph_Prelude_Int
+
+ ++ vars_Ord dph_Prelude_Word8
+ ++ vars_Num dph_Prelude_Word8
+ ++
+ [ mk' dph_Prelude_Word8 "div" "divV"
+ , mk' dph_Prelude_Word8 "mod" "modV"
+ , mk' dph_Prelude_Word8 "fromInt" "fromIntV"
+ , mk' dph_Prelude_Word8 "toInt" "toIntV"
+ ]
+
+ ++ vars_Ord dph_Prelude_Double
+ ++ vars_Num dph_Prelude_Double
+ ++ vars_Fractional dph_Prelude_Double
+ ++ vars_Floating dph_Prelude_Double
+ ++ vars_RealFrac dph_Prelude_Double
+ ++
+ [ mk dph_Prelude_Bool (fsLit "andP") dph_Prelude_Bool (fsLit "andPA")
, mk dph_Prelude_Bool (fsLit "orP") dph_Prelude_Bool (fsLit "orPA")
-- FIXME: temporary
, mk dph_Prelude_PArr (fsLit "combineP") dph_Combinators (fsLit "combine2PA")
]
where
- mk = (,,,)
+ mk = (,,,)
+ mk' mod v v' = mk mod (fsLit v) mod (fsLit v')
+
+ vars_Ord mod = [mk' mod "==" "eqV"
+ ,mk' mod "/=" "neqV"
+ ,mk' mod "<=" "leV"
+ ,mk' mod "<" "ltV"
+ ,mk' mod ">=" "geV"
+ ,mk' mod ">" "gtV"
+ ,mk' mod "min" "minV"
+ ,mk' mod "max" "maxV"
+ ,mk' mod "minimumP" "minimumPA"
+ ,mk' mod "maximumP" "maximumPA"
+ ,mk' mod "minIndexP" "minIndexPA"
+ ,mk' mod "maxIndexP" "maxIndexPA"
+ ]
+
+ vars_Num mod = [mk' mod "+" "plusV"
+ ,mk' mod "-" "minusV"
+ ,mk' mod "*" "multV"
+ ,mk' mod "negate" "negateV"
+ ,mk' mod "abs" "absV"
+ ,mk' mod "sumP" "sumPA"
+ ,mk' mod "productP" "productPA"
+ ]
+
+ vars_Fractional mod = [mk' mod "/" "divideV"
+ ,mk' mod "recip" "recipV"
+ ]
+
+ vars_Floating mod = [mk' mod "pi" "pi"
+ ,mk' mod "exp" "expV"
+ ,mk' mod "sqrt" "sqrtV"
+ ,mk' mod "log" "logV"
+ ,mk' mod "sin" "sinV"
+ ,mk' mod "tan" "tanV"
+ ,mk' mod "cos" "cosV"
+ ,mk' mod "asin" "asinV"
+ ,mk' mod "atan" "atanV"
+ ,mk' mod "acos" "acosV"
+ ,mk' mod "sinh" "sinhV"
+ ,mk' mod "tanh" "tanhV"
+ ,mk' mod "cosh" "coshV"
+ ,mk' mod "asinh" "asinhV"
+ ,mk' mod "atanh" "atanhV"
+ ,mk' mod "acosh" "acoshV"
+ ,mk' mod "**" "powV"
+ ,mk' mod "logBase" "logBaseV"
+ ]
+
+ vars_RealFrac mod = [mk' mod "fromInt" "fromIntV"
+ ,mk' mod "truncate" "truncateV"
+ ,mk' mod "round" "roundV"
+ ,mk' mod "ceiling" "ceilingV"
+ ,mk' mod "floor" "floorV"
+ ]
initBuiltinTyCons :: Builtins -> DsM [(Name, TyCon)]
initBuiltinTyCons bi
= do
-- parr <- externalTyCon dph_Prelude_PArr (fsLit "PArr")
+ dft_tcs <- defaultTyCons
return $ (tyConName funTyCon, closureTyCon bi)
: (parrTyConName, parrayTyCon bi)
-- FIXME: temporary
: (tyConName $ parrayTyCon bi, parrayTyCon bi)
- : [(tyConName tc, tc) | tc <- defaultTyCons]
+ : [(tyConName tc, tc) | tc <- dft_tcs]
-defaultTyCons :: [TyCon]
-defaultTyCons = [intTyCon, boolTyCon, doubleTyCon]
+defaultTyCons :: DsM [TyCon]
+defaultTyCons
+ = do
+ word8 <- dsLookupTyCon word8TyConName
+ return [intTyCon, boolTyCon, doubleTyCon, word8]
initBuiltinDataCons :: Builtins -> [(Name, DataCon)]
initBuiltinDataCons _ = [(dataConName dc, dc)| dc <- defaultDataCons]
, mk unitTyConName (dph_Instances mods) (fsLit "dPA_Unit")
, mk intTyConName (dph_Instances mods) (fsLit "dPA_Int")
+ , mk word8TyConName (dph_Instances mods) (fsLit "dPA_Word8")
, mk doubleTyConName (dph_Instances mods) (fsLit "dPA_Double")
, mk boolTyConName (dph_Instances mods) (fsLit "dPA_Bool")
]
where
mk name mod fs = (name, mod, fs)
- tups = map mk_tup [2..mAX_NDP_PROD]
+ tups = map mk_tup [2..mAX_DPH_PROD]
mk_tup n = mk (tyConName $ tupleTyCon Boxed n)
(dph_Instances mods)
(mkFastString $ "dPA_" ++ show n)
-- temporary
, mk intTyConName (dph_Instances mods) (fsLit "dPR_Int")
+ , mk word8TyConName (dph_Instances mods) (fsLit "dPR_Word8")
, mk doubleTyConName (dph_Instances mods) (fsLit "dPR_Double")
]
- ++ map mk_sum [2..mAX_NDP_SUM]
- ++ map mk_prod [2..mAX_NDP_PROD]
+ ++ map mk_sum [2..mAX_DPH_SUM]
+ ++ map mk_prod [2..mAX_DPH_PROD]
where
mk name mod fs = (name, mod, fs)
builtinBoxedTyCons _ =
[(tyConName intPrimTyCon, intTyCon)]
+
+initBuiltinScalars :: Builtins -> DsM [Var]
+initBuiltinScalars bi
+ = mapM (uncurry externalVar) (preludeScalars $ dphModules bi)
+
+
+preludeScalars :: Modules -> [(Module, FastString)]
+preludeScalars (Modules { dph_Prelude_Int = dph_Prelude_Int
+ , dph_Prelude_Word8 = dph_Prelude_Word8
+ , dph_Prelude_Double = dph_Prelude_Double
+ })
+ = [
+ mk dph_Prelude_Int "div"
+ , mk dph_Prelude_Int "mod"
+ , mk dph_Prelude_Int "sqrt"
+ ]
+ ++ scalars_Ord dph_Prelude_Int
+ ++ scalars_Num dph_Prelude_Int
+
+ ++ scalars_Ord dph_Prelude_Word8
+ ++ scalars_Num dph_Prelude_Word8
+ ++
+ [ mk dph_Prelude_Word8 "div"
+ , mk dph_Prelude_Word8 "mod"
+ , mk dph_Prelude_Word8 "fromInt"
+ , mk dph_Prelude_Word8 "toInt"
+ ]
+
+ ++ scalars_Ord dph_Prelude_Double
+ ++ scalars_Num dph_Prelude_Double
+ ++ scalars_Fractional dph_Prelude_Double
+ ++ scalars_Floating dph_Prelude_Double
+ ++ scalars_RealFrac dph_Prelude_Double
+ where
+ mk mod s = (mod, fsLit s)
+
+ scalars_Ord mod = [mk mod "=="
+ ,mk mod "/="
+ ,mk mod "<="
+ ,mk mod "<"
+ ,mk mod ">="
+ ,mk mod ">"
+ ,mk mod "min"
+ ,mk mod "max"
+ ]
+
+ scalars_Num mod = [mk mod "+"
+ ,mk mod "-"
+ ,mk mod "*"
+ ,mk mod "negate"
+ ,mk mod "abs"
+ ]
+
+ scalars_Fractional mod = [mk mod "/"
+ ,mk mod "recip"
+ ]
+
+ scalars_Floating mod = [mk mod "pi"
+ ,mk mod "exp"
+ ,mk mod "sqrt"
+ ,mk mod "log"
+ ,mk mod "sin"
+ ,mk mod "tan"
+ ,mk mod "cos"
+ ,mk mod "asin"
+ ,mk mod "atan"
+ ,mk mod "acos"
+ ,mk mod "sinh"
+ ,mk mod "tanh"
+ ,mk mod "cosh"
+ ,mk mod "asinh"
+ ,mk mod "atanh"
+ ,mk mod "acosh"
+ ,mk mod "**"
+ ,mk mod "logBase"
+ ]
+
+ scalars_RealFrac mod = [mk mod "fromInt"
+ ,mk mod "truncate"
+ ,mk mod "round"
+ ,mk mod "ceiling"
+ ,mk mod "floor"
+ ]
+
+
externalVar :: Module -> FastString -> DsM Var
externalVar mod fs
= dsLookupGlobalId =<< lookupOrig mod (mkVarOccFS fs)
externalTyCon :: Module -> FastString -> DsM TyCon
externalTyCon mod fs
- = dsLookupTyCon =<< lookupOrig mod (mkOccNameFS tcName fs)
+ = dsLookupTyCon =<< lookupOrig mod (mkTcOccFS fs)
externalType :: Module -> FastString -> DsM Type
externalType mod fs
tycon <- externalTyCon mod fs
return $ mkTyConApp tycon []
+externalClass :: Module -> FastString -> DsM Class
+externalClass mod fs
+ = dsLookupClass =<< lookupOrig mod (mkTcOccFS fs)
+
unitTyConName :: Name
unitTyConName = tyConName unitTyCon
| Just suffix <- lookupNameEnv prim_ty_cons (tyConName tycon)
= liftM Just
$ dsLookupTyCon =<< lookupOrig (dph_Unboxed mods)
- (mkOccName tcName $ "PArray" ++ suffix)
+ (mkTcOcc $ "PArray" ++ suffix)
| otherwise = return Nothing
projects / ghc-hetmet.git / blobdiff