Hoogle Search
Within LTS Haskell 24.4 (ghc-9.10.2)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()base Data.Foldable 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.
liftEq :: Eq1 f => (a -> b -> Bool) -> f a -> f b -> Boolbase Data.Functor.Classes Lift an equality test through the type constructor. The function will usually be applied to an equality function, but the more general type ensures that the implementation uses it to compare elements of the first container with elements of the second.
liftEq2 :: Eq2 f => (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Boolbase Data.Functor.Classes Lift equality tests through the type constructor. The function will usually be applied to equality functions, but the more general type ensures that the implementation uses them to compare elements of the first container with elements of the second.
comparisonEquivalence :: Comparison a -> Equivalence abase Data.Functor.Contravariant No documentation available.
defaultEquivalence :: Eq a => Equivalence abase Data.Functor.Contravariant Check for equivalence with ==. Note: The instances for Double and Float violate reflexivity for NaN.
getEquivalence :: Equivalence a -> a -> a -> Boolbase Data.Functor.Contravariant No documentation available.
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)base Data.Traversable 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
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)base Data.Traversable 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
class
TestEquality (f :: k -> Type)base Data.Type.Equality 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.testEquality :: forall (a :: k) (b :: k) . TestEquality f => f a -> f b -> Maybe (a :~: b)base Data.Type.Equality Conditionally prove the equality of a and b.