Hoogle Search

Within LTS Haskell 24.58 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. FixIOException :: FixIOException

   ghc-internal	GHC.Internal.Control.Exception.Base

   No documentation available.

2. module GHC.Internal.Control.Monad.Fix

   Monadic fixpoints. For a detailed discussion, see Levent Erkok's thesis, Value Recursion in Monadic Computations, Oregon Graduate Institute, 2002.

3. class Monad m => MonadFix (m :: Type -> Type)

   ghc-internal	GHC.Internal.Control.Monad.Fix

   Monads having fixed points with a 'knot-tying' semantics. Instances of MonadFix should satisfy the following laws:

   • Purity mfix (return . h) = return (fix h)
   • Left shrinking (or Tightening) mfix (\x -> a >>= \y -> f x y) = a >>= \y -> mfix (\x -> f x y)
   • Sliding mfix (liftM h . f) = liftM h (mfix (f . h)), for strict h.
   • Nesting mfix (\x -> mfix (\y -> f x y)) = mfix (\x -> f x x)
   This class is used in the translation of the recursive do notation supported by GHC and Hugs.

4. fix :: (a -> a) -> a

   ghc-internal	GHC.Internal.Control.Monad.Fix

   fix f is the least fixed point of the function f, i.e. the least defined x such that f x = x. When f is strict, this means that because, by the definition of strictness, f ⊥ = ⊥ and such the least defined fixed point of any strict function is ⊥.

   Examples

   We can write the factorial function using direct recursion as

   >>> let fac n = if n <= 1 then 1 else n * fac (n-1) in fac 5
   120
   

   This uses the fact that Haskell’s let introduces recursive bindings. We can rewrite this definition using fix, Instead of making a recursive call, we introduce a dummy parameter rec; when used within fix, this parameter then refers to fix’s argument, hence the recursion is reintroduced.

   >>> fix (\rec n -> if n <= 1 then 1 else n * rec (n-1)) 5
   120
   

   Using fix, we can implement versions of repeat as fix . (:) and cycle as fix . (++)

   >>> take 10 $ fix (0:)
   [0,0,0,0,0,0,0,0,0,0]
   

   >>> map (fix (\rec n -> if n < 2 then n else rec (n - 1) + rec (n - 2))) [1..10]
   [1,1,2,3,5,8,13,21,34,55]
   

   Implementation Details

   The current implementation of fix uses structural sharing

   fix f = let x = f x in x
   

   A more straightforward but non-sharing version would look like

   fix f = f (fix f)
   

5. mfix :: MonadFix m => (a -> m a) -> m a

   ghc-internal	GHC.Internal.Control.Monad.Fix

   The fixed point of a monadic computation. mfix f executes the action f only once, with the eventual output fed back as the input. Hence f should not be strict, for then mfix f would diverge.

6. fixST :: (a -> ST s a) -> ST s a

   ghc-internal	GHC.Internal.Control.Monad.ST

   Allow the result of an ST computation to be used (lazily) inside the computation. Note that if f is strict, fixST f = _|_.

7. fixST :: (a -> ST s a) -> ST s a

   ghc-internal	GHC.Internal.Control.Monad.ST.Imp

   Allow the result of an ST computation to be used (lazily) inside the computation. Note that if f is strict, fixST f = _|_.

8. fixST :: (a -> ST s a) -> ST s a

   ghc-internal	GHC.Internal.Control.Monad.ST.Lazy

   Allow the result of an ST computation to be used (lazily) inside the computation. Note that if f is strict, fixST f = _|_.

9. fixST :: (a -> ST s a) -> ST s a

   ghc-internal	GHC.Internal.Control.Monad.ST.Lazy.Imp

   Allow the result of an ST computation to be used (lazily) inside the computation. Note that if f is strict, fixST f = _|_.

10. data Fixity

    ghc-internal	GHC.Internal.Data.Data

    Fixity of constructors

Page 251 of many | Previous | Next