Hoogle Search

Within LTS Haskell 24.28 (ghc-9.10.3)

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

Exact lookup

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

   streaming	Streaming.Prelude

   The mapMaybe function is a version of map which can throw out elements. In particular, the functional argument returns something of type Maybe b. If this is Nothing, no element is added on to the result Stream. If it is Just b, then b is included in the result Stream.

2. mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream (Of a) m r -> Stream (Of b) m r

   streaming	Streaming.Prelude

   Map monadically over a stream, producing a new stream only containing the Just values.

3. mapOf :: (a -> b) -> Of a r -> Of b r

   streaming	Streaming.Prelude

   Map a function over the first element of an Of pair

   >>> S.mapOf even (1:>"hi")
   False :> "hi"
   

   mapOf is just first from the Bifunctor instance

   >>> first even (1:>"hi")
   False :> "hi"
   

   and is contained in the _first lens

   >>> import Lens.Micro
   
   >>> over S._first even (1:>"hi")
   False :> "hi"
   

4. mapped :: (Monad m, Functor f) => (forall x . () => f x -> m (g x)) -> Stream f m r -> Stream g m r

   streaming	Streaming.Prelude

   Map layers of one functor to another with a transformation involving the base monad. This function is completely functor-general. It is often useful with the more concrete type

   mapped :: (forall x. Stream (Of a) IO x -> IO (Of b x)) -> Stream (Stream (Of a) IO) IO r -> Stream (Of b) IO r
   

   to process groups which have been demarcated in an effectful, IO-based stream by grouping functions like group, split or breaks. Summary functions like fold, foldM, mconcat or toList are often used to define the transformation argument. For example:

   >>> S.toList_ $ S.mapped S.toList $ S.split 'c' (S.each "abcde")
   ["ab","de"]
   

   maps and mapped obey these rules:

   maps id              = id
   mapped return        = id
   maps f . maps g      = maps (f . g)
   mapped f . mapped g  = mapped (f <=< g)
   maps f . mapped g    = mapped (fmap f . g)
   mapped f . maps g    = mapped (f <=< fmap g)
   

   maps is more fundamental than mapped, which is best understood as a convenience for effecting this frequent composition:

   mapped phi = decompose . maps (Compose . phi)
   

5. mappedPost :: (Monad m, Functor g) => (forall x . () => f x -> m (g x)) -> Stream f m r -> Stream g m r

   streaming	Streaming.Prelude

   A version of mapped that imposes a Functor constraint on the target functor rather than the source functor. This version should be preferred if fmap on the target functor is cheaper.

6. maps :: forall (m :: Type -> Type) f g r . (Monad m, Functor f) => (forall x . () => f x -> g x) -> Stream f m r -> Stream g m r

   streaming	Streaming.Prelude

   Map layers of one functor to another with a transformation. Compare hoist, which has a similar effect on the monadic parameter.

   maps id = id
   maps f . maps g = maps (f . g)
   

7. mapsPost :: forall (m :: Type -> Type) f g r . (Monad m, Functor g) => (forall x . () => f x -> g x) -> Stream f m r -> Stream g m r

   streaming	Streaming.Prelude

   Map layers of one functor to another with a transformation. Compare hoist, which has a similar effect on the monadic parameter.

   mapsPost id = id
   mapsPost f . mapsPost g = mapsPost (f . g)
   mapsPost f = maps f
   

   mapsPost is essentially the same as maps, but it imposes a Functor constraint on its target functor rather than its source functor. It should be preferred if fmap is cheaper for the target functor than for the source functor.

8. mapFields :: forall c (ts :: [(Symbol, Type)]) . RecMapMethod c ElField ts => (forall a . c a => a -> a) -> FieldRec ts -> FieldRec ts

   vinyl	Data.Vinyl

   Apply a typeclass method to each field of a FieldRec. This is a specialization of rmapMethod.

9. mapFields :: forall c (ts :: [(Symbol, Type)]) . RecMapMethod c ElField ts => (forall a . c a => a -> a) -> FieldRec ts -> FieldRec ts

   vinyl	Data.Vinyl.Class.Method

   Apply a typeclass method to each field of a FieldRec. This is a specialization of rmapMethod.

10. mapMaybe :: Filterable f => (a -> Maybe b) -> f a -> f b

    witherable	Witherable

    Like mapMaybe.

Page 142 of many | Previous | Next