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. imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()

   lens	Control.Lens.Combinators

   Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results. When you don't need access to the index then mapMOf_ is more flexible in what it accepts.

   mapMOf_ l ≡ imapMOf l . const
   

   imapMOf_ :: Monad m => IndexedGetter i s a     -> (i -> a -> m r) -> s -> m ()
   imapMOf_ :: Monad m => IndexedFold i s a       -> (i -> a -> m r) -> s -> m ()
   imapMOf_ :: Monad m => IndexedLens' i s a      -> (i -> a -> m r) -> s -> m ()
   imapMOf_ :: Monad m => IndexedTraversal' i s a -> (i -> a -> m r) -> s -> m ()
   

2. imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m ()

   lens	Control.Lens.Combinators

   Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results. When you don't need access to the index then mapMOf_ is more flexible in what it accepts.

   mapM_ ≡ imapM . const
   

3. imapOf :: AnIndexedSetter i s t a b -> (i -> a -> b) -> s -> t

   lens	Control.Lens.Combinators

   Deprecated: Use iover

4. imapped :: forall i (f :: Type -> Type) a b . FunctorWithIndex i f => IndexedSetter i (f a) (f b) a b

   lens	Control.Lens.Combinators

   The IndexedSetter for a FunctorWithIndex. If you don't need access to the index, then mapped is more flexible in what it accepts.

5. lmap :: Profunctor p => (a -> b) -> p b c -> p a c

   lens	Control.Lens.Combinators

   Map the first argument contravariantly.

   lmap f ≡ dimap f id
   

6. lmapping :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type) s t a b x y . (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p a x) (q b y) (p s x) (q t y)

   lens	Control.Lens.Combinators

   Lift an Iso contravariantly into the left argument of a Profunctor.

   lmapping :: Profunctor p => Iso s t a b -> Iso (p a x) (p b y) (p s x) (p t y)
   lmapping :: Profunctor p => Iso' s a -> Iso' (p a x) (p s x)
   

7. rmap :: Profunctor p => (b -> c) -> p a b -> p a c

   lens	Control.Lens.Combinators

   Map the second argument covariantly.

   rmap ≡ dimap id
   

8. rmapping :: forall (p :: Type -> Type -> Type) (q :: Type -> Type -> Type) s t a b x y . (Profunctor p, Profunctor q) => AnIso s t a b -> Iso (p x s) (q y t) (p x a) (q y b)

   lens	Control.Lens.Combinators

   Lift an Iso covariantly into the right argument of a Profunctor.

   rmapping :: Profunctor p => Iso s t a b -> Iso (p x s) (p y t) (p x a) (p y b)
   rmapping :: Profunctor p => Iso' s a -> Iso' (p x s) (p x a)
   

9. concatMapOf :: Getting [r] s a -> (a -> [r]) -> s -> [r]

   lens	Control.Lens.Fold

   Map a function over all the targets of a Fold of a container and concatenate the resulting lists.

   >>> concatMapOf both (\x -> [x, x + 1]) (1,3)
   [1,2,3,4]
   

   concatMap ≡ concatMapOf folded
   

   concatMapOf :: Getter s a     -> (a -> [r]) -> s -> [r]
   concatMapOf :: Fold s a       -> (a -> [r]) -> s -> [r]
   concatMapOf :: Lens' s a      -> (a -> [r]) -> s -> [r]
   concatMapOf :: Iso' s a       -> (a -> [r]) -> s -> [r]
   concatMapOf :: Traversal' s a -> (a -> [r]) -> s -> [r]
   

10. foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r

    lens	Control.Lens.Fold

    Fold a value using its Foldable instance using explicitly provided Monoid operations. This is like foldMap where the Monoid instance can be manually specified.

    foldMapBy mappend mempty ≡ foldMap
    

    >>> foldMapBy (+) 0 length ["hello","world"]
    10
    

Page 420 of many | Previous | Next