ghc-prim-0.3.1.0: GHC primitives

Copyright(c) The University of Glasgow 2009
Licensesee libraries/ghc-prim/LICENSE
Maintainercvs-ghc@haskell.org
Stabilityinternal
Portabilitynon-portable (GHC Extensions)
Safe HaskellTrustworthy
LanguageHaskell2010

GHC.Magic

Description

GHC magic.

Use GHC.Exts from the base package instead of importing this module directly.

Synopsis

Documentation

inline :: a -> a Source

The call '(inline f)' arranges that f is inlined, regardless of its size. More precisely, the call '(inline f)' rewrites to the right-hand side of 'f'\'s definition. This allows the programmer to control inlining from a particular call site rather than the definition site of the function (c.f. INLINE pragmas).

This inlining occurs regardless of the argument to the call or the size of 'f'\'s definition; it is unconditional. The main caveat is that 'f'\'s definition must be visible to the compiler; it is therefore recommended to mark the function with an INLINABLE pragma at its definition so that GHC guarantees to record its unfolding regardless of size.

If no inlining takes place, the inline function expands to the identity function in Phase zero, so its use imposes no overhead.

lazy :: a -> a Source

The lazy function restrains strictness analysis a little. The call '(lazy e)' means the same as e, but lazy has a magical property so far as strictness analysis is concerned: it is lazy in its first argument, even though its semantics is strict. After strictness analysis has run, calls to lazy are inlined to be the identity function.

This behaviour is occasionally useful when controlling evaluation order. Notably, lazy is used in the library definition of par:

par :: a -> b -> b
par x y = case (par# x) of _ -> lazy y

If lazy were not lazy, par would look strict in y which would defeat the whole purpose of par.

Like seq, the argument of lazy can have an unboxed type.