Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

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

  1. 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)

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

    lens Control.Lens.Combinators

    Map the second argument covariantly. 

    rmap ≡ dimap id

  3. 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)

  4. 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]

  5. 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

  6. foldMapByOf :: Fold s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r

    lens Control.Lens.Fold

    Fold a value using a specified Fold and Monoid operations. This is like foldMapBy where the Foldable instance can be manually specified. 

    foldMapByOf folded ≡ foldMapBy

    foldMapByOf :: Getter s a     -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldMapByOf :: Fold s a       -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldMapByOf :: Traversal' s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldMapByOf :: Lens' s a      -> (r -> r -> r) -> r -> (a -> r) -> s -> r
foldMapByOf :: Iso' s a       -> (r -> r -> r) -> r -> (a -> r) -> s -> r

    >>> foldMapByOf both (+) 0 length ("hello","world")
10

  7. foldMapOf :: Getting r s a -> (a -> r) -> s -> r

    lens Control.Lens.Fold

    Map each part of a structure viewed through a Lens, Getter, Fold or Traversal to a monoid and combine the results. 

    >>> foldMapOf (folded . both . _Just) Sum [(Just 21, Just 21)]
Sum {getSum = 42}

    foldMap = foldMapOf folded

    foldMapOf ≡ views
ifoldMapOf l = foldMapOf l . Indexed

    foldMapOf ::                Getter s a      -> (a -> r) -> s -> r
foldMapOf :: Monoid r    => Fold s a        -> (a -> r) -> s -> r
foldMapOf :: Semigroup r => Fold1 s a       -> (a -> r) -> s -> r
foldMapOf ::                Lens' s a       -> (a -> r) -> s -> r
foldMapOf ::                Iso' s a        -> (a -> r) -> s -> r
foldMapOf :: Monoid r    => Traversal' s a  -> (a -> r) -> s -> r
foldMapOf :: Semigroup r => Traversal1' s a -> (a -> r) -> s -> r
foldMapOf :: Monoid r    => Prism' s a      -> (a -> r) -> s -> r

    foldMapOf :: Getting r s a -> (a -> r) -> s -> r

  8. iconcatMapOf :: IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]

    lens Control.Lens.Fold

    Concatenate the results of a function of the elements of an IndexedFold or IndexedTraversal with access to the index. When you don't need access to the index then concatMapOf is more flexible in what it accepts. 

    concatMapOf l ≡ iconcatMapOf l . const
iconcatMapOf ≡ ifoldMapOf

    iconcatMapOf :: IndexedGetter i s a     -> (i -> a -> [r]) -> s -> [r]
iconcatMapOf :: IndexedFold i s a       -> (i -> a -> [r]) -> s -> [r]
iconcatMapOf :: IndexedLens' i s a      -> (i -> a -> [r]) -> s -> [r]
iconcatMapOf :: IndexedTraversal' i s a -> (i -> a -> [r]) -> s -> [r]

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

    lens Control.Lens.Fold

    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

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

    lens Control.Lens.Fold

    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 419 of many | Previous | Next