Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

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

  1. isSuffixOf :: Eq a => [a] -> [a] -> Bool

    base Data.List

    The isSuffixOf function takes two lists and returns True iff the first list is a suffix of the second.

    Examples

    >>> "ld!" `isSuffixOf` "Hello World!"
True

    >>> "World" `isSuffixOf` "Hello World!"
False
    The second list must be finite; however the first list may be infinite: 
    >>> [0..] `isSuffixOf` [0..99]
False

    >>> [0..99] `isSuffixOf` [0..]
* Hangs forever *

  2. stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]

    base Data.List

    The stripPrefix function drops the given prefix from a list. It returns Nothing if the list did not start with the prefix given, or Just the list after the prefix, if it does.

    Examples
    >>> stripPrefix "foo" "foobar"
Just "bar"

    >>> stripPrefix "foo" "foo"
Just ""

    >>> stripPrefix "foo" "barfoo"
Nothing

    >>> stripPrefix "foo" "barfoobaz"
Nothing

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

    base Data.Function

    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)

  4. data FixIOException

    base Control.Exception.Base

    The exception thrown when an infinite cycle is detected in fixIO.

  5. FixIOException :: FixIOException

    base Control.Exception.Base

    No documentation available.

  6. module Control.Monad.Fix

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

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

    base Control.Monad.Fix

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

    This class is used in the translation of the recursive do notation supported by GHC and Hugs.

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

    base 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)

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

    base 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.

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

    base 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 = _|_.

Page 21 of many | Previous | Next