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. joinLeq :: JoinSemiLattice a => a -> a -> Bool

    numhask NumHask.Algebra.Lattice

    The partial ordering induced by the join-semilattice structure

  2. meetLeq :: MeetSemiLattice a => a -> a -> Bool

    numhask NumHask.Algebra.Lattice

    The partial ordering induced by the meet-semilattice structure

  3. aboutEqual :: (Epsilon a, Lattice a, Subtractive a) => a -> a -> Bool

    numhask NumHask.Algebra.Metric

    Approximate equality 

    >>> aboutEqual zero (epsilon :: Double)
True

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

    numhask NumHask.Prelude

    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. sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)

    numhask NumHask.Prelude

    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

  6. sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)

    numhask NumHask.Prelude

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

    Examples

    Basic usage: For the first two examples we show sequenceA fully evaluating a a structure and collecting the results. 
    >>> sequenceA [Just 1, Just 2, Just 3]
Just [1,2,3]

    >>> sequenceA [Right 1, Right 2, Right 3]
Right [1,2,3]
    The next two example show Nothing and Just will short circuit the resulting structure if present in the input. For more context, check the Traversable instances for Either and Maybe. 
    >>> sequenceA [Just 1, Just 2, Just 3, Nothing]
Nothing

    >>> sequenceA [Right 1, Right 2, Right 3, Left 4]
Left 4

  7. sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()

    numhask NumHask.Prelude

    Evaluate each action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequenceA. sequenceA_ is just like sequence_, but generalised to Applicative actions.

    Examples

    Basic usage: 
    >>> sequenceA_ [print "Hello", print "world", print "!"]
"Hello"
"world"
"!"

  8. sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

    numhask NumHask.Prelude

    Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence. sequence_ is just like sequenceA_, but specialised to monadic actions.

  9. sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

    numhask NumHask.Prelude

    Evaluate each monadic action in the structure from left to right, and ignore the results. For a version that doesn't ignore the results see sequence. sequence_ is just like sequenceA_, but specialised to monadic actions.

  10. class TestEquality (f :: k -> Type)

    parameterized-utils Data.Parameterized.BoolRepr

    This class contains types where you can learn the equality of two types from information contained in terms. The result should be Just Refl if and only if the types applied to f are equal: 

    testEquality (x :: f a) (y :: f b) = Just Refl ⟺ a = b
    Typically, only singleton types should inhabit this class. In that case type argument equality coincides with term equality: 
    testEquality (x :: f a) (y :: f b) = Just Refl ⟺ a = b ⟺ x = y

    isJust (testEquality x y) = x == y
    Singleton types are not required, however, and so the latter two would-be laws are not in fact valid in general.

Page 376 of many | Previous | Next