Hoogle Search

Within LTS Haskell 24.52 (ghc-9.10.3)

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

  1. iOExtensionPointSetRequiredType :: (HasCallStack, MonadIO m) => IOExtensionPoint -> GType -> m ()

    gi-gio GI.Gio.Structs.IOExtensionPoint

    Sets the required type for extensionPoint to type. All implementations must henceforth have this type.

  2. sendRequest :: (RedisCtx m f, RedisResult a) => [ByteString] -> m (f a)

    hedis Database.Redis

    sendRequest can be used to implement commands from experimental versions of Redis. An example of how to implement a command is given below. 

    -- |Redis DEBUG OBJECT command
debugObject :: ByteString -> Redis (Either Reply ByteString)
debugObject key = sendRequest ["DEBUG", "OBJECT", key]

  3. sendRequest :: (RedisCtx m f, RedisResult a) => [ByteString] -> m (f a)

    hedis Database.Redis.Sentinel

    sendRequest can be used to implement commands from experimental versions of Redis. An example of how to implement a command is given below. 

    -- |Redis DEBUG OBJECT command
debugObject :: ByteString -> Redis (Either Reply ByteString)
debugObject key = sendRequest ["DEBUG", "OBJECT", key]

  4. seq :: a -> b -> b

    relude Relude.Base

    The value of seq a b is bottom if a is bottom, and otherwise equal to b. In other words, it evaluates the first argument a to weak head normal form (WHNF). seq is usually introduced to improve performance by avoiding unneeded laziness. A note on evaluation order: the expression seq a b does not guarantee that a will be evaluated before b. The only guarantee given by seq is that the both a and b will be evaluated before seq returns a value. In particular, this means that b may be evaluated before a. If you need to guarantee a specific order of evaluation, you must use the function pseq from the "parallel" package.

  5. data Seq a

    relude Relude.Container.Reexport

    General-purpose finite sequences.

  6. module Relude.DeepSeq

    This module contains useful functions to evaluate expressions to weak-head normal form (WHNF) or just normal form (NF). Useful to force traces or errors inside monadic computations or to remove space leaks.

  7. deepseq :: NFData a => a -> b -> b

    relude Relude.DeepSeq

    deepseq: fully evaluates the first argument, before returning the second. The name deepseq is used to illustrate the relationship to seq: where seq is shallow in the sense that it only evaluates the top level of its argument, deepseq traverses the entire data structure evaluating it completely. deepseq can be useful for forcing pending exceptions, eradicating space leaks, or forcing lazy I/O to happen. It is also useful in conjunction with parallel Strategies (see the parallel package). There is no guarantee about the ordering of evaluation. The implementation may evaluate the components of the structure in any order or in parallel. To impose an actual order on evaluation, use pseq from Control.Parallel in the parallel package.

  8. bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)

    relude Relude.Foldable.Reexport

    Sequences all the actions in a structure, building a new structure with the same shape using the results of the actions. For a version that ignores the results, see bisequence_. 

    bisequence ≡ bitraverse id id

    Examples

    Basic usage: 
    >>> bisequence (Just 4, Nothing)
Nothing

    >>> bisequence (Just 4, Just 5)
Just (4,5)

    >>> bisequence ([1, 2, 3], [4, 5])
[(1,4),(1,5),(2,4),(2,5),(3,4),(3,5)]

  9. bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()

    relude Relude.Foldable.Reexport

    Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results, see bisequence.

    Examples

    Basic usage: 
    >>> bisequence_ (print "Hello", print "World")
"Hello"
"World"

    >>> bisequence_ (Left (print "Hello"))
"Hello"

    >>> bisequence_ (Right (print "World"))
"World"

  10. sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

    relude Relude.Foldable.Reexport

    Evaluate each monadic action in the structure from left to right, and collect the results. For a version that ignores the results see sequence_.

    Examples

    Basic usage: The first two examples are instances where the input and and output of sequence are isomorphic. 
    >>> sequence $ Right [1,2,3,4]
[Right 1,Right 2,Right 3,Right 4]

    >>> sequence $ [Right 1,Right 2,Right 3,Right 4]
Right [1,2,3,4]
    The following examples demonstrate short circuit behavior for sequence. 
    >>> sequence $ Left [1,2,3,4]
Left [1,2,3,4]

    >>> sequence $ [Left 0, Right 1,Right 2,Right 3,Right 4]
Left 0

Page 299 of many | Previous | Next