Hoogle Search

Within LTS Haskell 24.38 (ghc-9.10.3)

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

  1. scanMaybe :: forall (m :: Type -> Type) a b . Monad m => Fold m a (Maybe b) -> Stream m a -> Stream m b

    streamly-core Streamly.Data.Stream

    Use a filtering fold on a stream. 

    >>> scanMaybe f = Stream.catMaybes . Stream.postscan f

  2. catMaybes :: forall (m :: Type -> Type) a b . Monad m => Fold m a b -> Fold m (Maybe a) b

    streamly-core Streamly.Internal.Data.Fold

    Modify a fold to receive a Maybe input, the Just values are unwrapped and sent to the original fold, Nothing values are discarded. 

    >>> catMaybes = Fold.mapMaybe id

>>> catMaybes = Fold.filter isJust . Fold.lmap fromJust

  3. mapMaybe :: forall (m :: Type -> Type) a b r . Monad m => (a -> Maybe b) -> Fold m b r -> Fold m a r

    streamly-core Streamly.Internal.Data.Fold

    mapMaybe f fold maps a Maybe returning function f on the input of the fold, filters out Nothing elements, and return the values extracted from Just. 

    >>> mapMaybe f = Fold.lmap f . Fold.catMaybes

>>> mapMaybe f = Fold.mapMaybeM (return . f)

    >>> f x = if even x then Just x else Nothing

>>> fld = Fold.mapMaybe f Fold.toList

>>> Stream.fold fld (Stream.enumerateFromTo 1 10)
[2,4,6,8,10]

  4. mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Fold m b r -> Fold m a r

    streamly-core Streamly.Internal.Data.Fold 

    >>> mapMaybeM f = Fold.lmapM f . Fold.catMaybes

  5. scanMaybe :: forall (m :: Type -> Type) a b c . Monad m => Fold m a (Maybe b) -> Fold m b c -> Fold m a c

    streamly-core Streamly.Internal.Data.Fold

    Use a Maybe returning fold as a filtering scan. 

    >>> scanMaybe p f = Fold.postscan p (Fold.catMaybes f)
    Pre-release

  6. toMaybe :: Maybe' a -> Maybe a

    streamly-core Streamly.Internal.Data.Maybe.Strict

    Convert strict Maybe' to lazy Maybe

  7. fromFoldMaybe :: forall (m :: Type -> Type) a b . Monad m => String -> Fold m a (Maybe b) -> Parser a m b

    streamly-core Streamly.Internal.Data.Parser

    Convert a Maybe returning fold to an error returning parser. The first argument is the error message that the parser would return when the fold returns Nothing. Pre-release

  8. catMaybes :: forall (m :: Type -> Type) a . Monad m => Stream m (Maybe a) -> Stream m a

    streamly-core Streamly.Internal.Data.Stream

    In a stream of Maybes, discard Nothings and unwrap Justs. 

    >>> catMaybes = Stream.mapMaybe id

>>> catMaybes = fmap fromJust . Stream.filter isJust
    Pre-release

  9. mapMaybe :: forall (m :: Type -> Type) a b . Monad m => (a -> Maybe b) -> Stream m a -> Stream m b

    streamly-core Streamly.Internal.Data.Stream

    Map a Maybe returning function to a stream, filter out the Nothing elements, and return a stream of values extracted from Just. Equivalent to: 

    >>> mapMaybe f = Stream.catMaybes . fmap f

  10. mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b

    streamly-core Streamly.Internal.Data.Stream

    Like mapMaybe but maps a monadic function. Equivalent to: 

    >>> mapMaybeM f = Stream.catMaybes . Stream.mapM f

    >>> mapM f = Stream.mapMaybeM (\x -> Just <$> f x)

Page 252 of many | Previous | Next