Safe Haskell | None |
---|
- eTuple :: [E] -> E
- eTuple' :: [E] -> E
- unboxedTuple :: (CanType e, ~ * (TypeOf e) E) => [e] -> Lit e E
- unboxedUnit :: E
- unboxedTyUnit :: E
- class ToE a where
- class ToEzh a where
- eCons :: E -> E -> E
- eNil :: E -> E
- emptyCase :: E
- eCaseTup :: E -> [TVr] -> E -> E
- eCaseTup' :: E -> [TVr] -> E -> E
- eJustIO :: E -> E -> E
- eCase :: E -> [Alt E] -> E -> E
- eLet :: TVr -> E -> E -> E
- eStrictLet :: TVr' E -> E -> E -> E
- substLet :: [(TVr, E)] -> E -> E
- substLet' :: [(TVr, E)] -> E -> E
- eLetRec :: [(TVr, E)] -> E -> E
- prim_seq :: E -> E -> E
- prim_unsafeCoerce :: E -> E -> E
- from_unsafeCoerce :: Monad m => E -> m (E, E)
- isState_ :: E -> Bool
- unsafeCoerceOpt :: E -> (Int, E, E -> E)
- isFullyConst :: E -> Bool
- isAtomic :: E -> Bool
- isManifestAtomic :: E -> Bool
- isSmall :: E -> Bool
- isCheap :: E -> Bool
- isLifted :: E -> Bool
- whnfOrBot :: E -> Bool
- isUnboxed :: E -> Bool
- safeToDup :: E -> Bool
- eToPat :: Monad m => E -> m (Lit TVr E)
- patToE :: Monad m => Lit TVr E -> m E
Documentation
eLet :: TVr -> E -> E -> ESource
This takes care of types right away, it simplifies various other things to do it this way.
eStrictLet :: TVr' E -> E -> E -> ESource
strict version of let, evaluates argument before assigning it.
prim_unsafeCoerce :: E -> E -> ESource
isFullyConst :: E -> BoolSource
whether a value is a compile time constant
whether a value may be used as an argument to an application, literal, or primitive these may be duplicated with no code size or runtime penalty
isManifestAtomic :: E -> BoolSource
whether a type is obviously atomic. fast and lazy, doesn't recurse True -> definitely atomic False -> maybe atomic
whether an expression is small enough that it can be duplicated without code size growing too much. (work may be repeated)
whether an expression may be duplicated or pushed inside a lambda without duplicating too much work