Hoogle Search

Within LTS Haskell 24.40 (ghc-9.10.3)

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

  1. ifoldMapByOf :: IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r

    diagrams-lib Diagrams.Prelude

    No documentation available.

  2. ifoldMapOf :: IndexedGetting i m s a -> (i -> a -> m) -> s -> m

    diagrams-lib Diagrams.Prelude

    Fold an IndexedFold or IndexedTraversal by mapping indices and values to an arbitrary Monoid with access to the i. When you don't need access to the index then foldMapOf is more flexible in what it accepts. 

    foldMapOf l ≡ ifoldMapOf l . const

    ifoldMapOf ::             IndexedGetter i s a     -> (i -> a -> m) -> s -> m
ifoldMapOf :: Monoid m => IndexedFold i s a       -> (i -> a -> m) -> s -> m
ifoldMapOf ::             IndexedLens' i s a      -> (i -> a -> m) -> s -> m
ifoldMapOf :: Monoid m => IndexedTraversal' i s a -> (i -> a -> m) -> s -> m

  3. imap :: FunctorWithIndex i f => (i -> a -> b) -> f a -> f b

    diagrams-lib Diagrams.Prelude

    Map with access to the index.

  4. imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)

    diagrams-lib Diagrams.Prelude

    Generalizes mapAccumL to add access to the index. imapAccumL accumulates state from left to right. 

    mapAccumL ≡ imapAccumL . const

  5. imapAccumLOf :: Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

    diagrams-lib Diagrams.Prelude

    Generalizes mapAccumL to an arbitrary IndexedTraversal with access to the index. imapAccumLOf accumulates state from left to right. 

    mapAccumLOf l ≡ imapAccumLOf l . const

    imapAccumLOf :: IndexedLens i s t a b      -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
imapAccumLOf :: IndexedTraversal i s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

  6. imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)

    diagrams-lib Diagrams.Prelude

    Generalizes mapAccumR to add access to the index. imapAccumR accumulates state from right to left. 

    mapAccumR ≡ imapAccumR . const

  7. imapAccumROf :: Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

    diagrams-lib Diagrams.Prelude

    Generalizes mapAccumR to an arbitrary IndexedTraversal with access to the index. imapAccumROf accumulates state from right to left. 

    mapAccumROf l ≡ imapAccumROf l . const

    imapAccumROf :: IndexedLens i s t a b      -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
imapAccumROf :: IndexedTraversal i s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

  8. imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)

    diagrams-lib Diagrams.Prelude

    Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results, with access the index. When you don't need access to the index mapM is more liberal in what it can accept. 

    mapM ≡ imapM . const

  9. imapMOf :: Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t

    diagrams-lib Diagrams.Prelude

    Map each element of a structure targeted by a Lens to a monadic action, evaluate these actions from left to right, and collect the results, with access its position. When you don't need access to the index mapMOf is more liberal in what it can accept. 

    mapMOf l ≡ imapMOf l . const

    imapMOf :: Monad m => IndexedLens       i s t a b -> (i -> a -> m b) -> s -> m t
imapMOf :: Monad m => IndexedTraversal  i s t a b -> (i -> a -> m b) -> s -> m t
imapMOf :: Bind  m => IndexedTraversal1 i s t a b -> (i -> a -> m b) -> s -> m t

  10. imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()

    diagrams-lib Diagrams.Prelude

    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 ()

Page 501 of many | Previous | Next