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