Hoogle Search

Within LTS Haskell 24.51 (ghc-9.10.3)

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

Exact lookup

1. traverseMaybeMissing :: Applicative f => (k -> x -> f (Maybe y)) -> WhenMissing f k x y

   containers	Data.Map.Strict.Internal

   Traverse over the entries whose keys are missing from the other map, optionally producing values to put in the result. This is the most powerful WhenMissing tactic, but others are usually more efficient.

2. traverseMaybeWithKey :: Applicative f => (k -> a -> f (Maybe b)) -> Map k a -> f (Map k b)

   containers	Data.Map.Strict.Internal

   Traverse keys/values and collect the Just results.

3. zipWithMaybeAMatched :: Applicative f => (k -> x -> y -> f (Maybe z)) -> WhenMatched f k x y z

   containers	Data.Map.Strict.Internal

   When a key is found in both maps, apply a function to the key and values, perform the resulting action, and maybe use the result in the merged map. This is the fundamental WhenMatched tactic.

4. zipWithMaybeMatched :: forall (f :: Type -> Type) k x y z . Applicative f => (k -> x -> y -> Maybe z) -> WhenMatched f k x y z

   containers	Data.Map.Strict.Internal

   When a key is found in both maps, apply a function to the key and values and maybe use the result in the merged map.

   zipWithMaybeMatched :: (k -> x -> y -> Maybe z)
   -> SimpleWhenMatched k x y z
   

5. foldToMaybeTree :: (b -> b -> b) -> (a -> b) -> FingerTree a -> Maybe b

   containers	Data.Sequence.Internal.Sorting

   A foldMap-like function, specialized to the Option monoid, which takes advantage of the internal structure of Seq to avoid wrapping in Maybe at certain points.

6. foldToMaybeWithIndexTree :: (b -> b -> b) -> (Int -> Elem y -> b) -> Int -> FingerTree (Elem y) -> Maybe b

   containers	Data.Sequence.Internal.Sorting

   A foldMapWithIndex-like function, specialized to the Option monoid, which takes advantage of the internal structure of Seq to avoid wrapping in Maybe at certain points.

7. exceptToMaybeT :: forall (m :: Type -> Type) e a . Functor m => ExceptT e m a -> MaybeT m a

   transformers	Control.Monad.Trans.Maybe

   Convert a ExceptT computation to MaybeT, discarding the value of any exception.

8. hoistMaybe :: forall (m :: Type -> Type) b . Applicative m => Maybe b -> MaybeT m b

   transformers	Control.Monad.Trans.Maybe

   Convert a Maybe computation to MaybeT.

9. mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b

   transformers	Control.Monad.Trans.Maybe

   Transform the computation inside a MaybeT.

   • runMaybeT (mapMaybeT f m) = f (runMaybeT
     m)

10. runMaybeT :: MaybeT (m :: Type -> Type) a -> m (Maybe a)

    transformers	Control.Monad.Trans.Maybe

    No documentation available.

Page 110 of many | Previous | Next