mono-traversable-1.0.15.3: Type classes for mapping, folding, and traversing monomorphic containers

Safe Haskell | Safe-Inferred
Language | Haskell2010

Data.MonoTraversable

Description

Type classes mirroring standard typeclasses, but working with monomorphic containers.

The motivation is that some commonly used data types (i.e., `ByteString` and `Text`) do not allow for instances of typeclasses like `Functor` and `Foldable`, since they are monomorphic structures. This module allows both monomorphic and polymorphic data types to be instances of the same typeclasses.

All of the laws for the polymorphic typeclasses apply to their monomorphic cousins. Thus, even though a `MonoFunctor` instance for `Set` could theoretically be defined, it is omitted since it could violate the functor law of ``omap` f . `omap` g = `omap` (f . g)`.

Note that all typeclasses have been prefixed with `Mono`, and functions have been prefixed with `o`. The mnemonic for `o` is "only one", or alternatively "it's mono, but m is overused in Haskell, so we'll use the second letter instead." (Agreed, it's not a great mangling scheme, input is welcome!)

Synopsis

- type family Element mono
- class MonoFunctor mono where
  - omap :: (Element mono -> Element mono) -> mono -> mono
- replaceElem :: (MonoFunctor mono, Eq (Element mono)) => Element mono -> Element mono -> mono -> mono
- replaceElemStrictText :: Char -> Char -> Text -> Text
- replaceElemLazyText :: Char -> Char -> Text -> Text
- class MonoFoldable mono where
  - ofoldMap :: Monoid m => (Element mono -> m) -> mono -> m
  - ofoldr :: (Element mono -> b -> b) -> b -> mono -> b
  - ofoldl' :: (a -> Element mono -> a) -> a -> mono -> a
  - otoList :: mono -> [Element mono]
  - oall :: (Element mono -> Bool) -> mono -> Bool
  - oany :: (Element mono -> Bool) -> mono -> Bool
  - onull :: mono -> Bool
  - olength :: mono -> Int
  - olength64 :: mono -> Int64
  - ocompareLength :: Integral i => mono -> i -> Ordering
  - otraverse_ :: Applicative f => (Element mono -> f b) -> mono -> f ()
  - ofor_ :: Applicative f => mono -> (Element mono -> f b) -> f ()
  - omapM_ :: Applicative m => (Element mono -> m ()) -> mono -> m ()
  - oforM_ :: Applicative m => mono -> (Element mono -> m ()) -> m ()
  - ofoldlM :: Monad m => (a -> Element mono -> m a) -> a -> mono -> m a
  - ofoldMap1Ex :: Semigroup m => (Element mono -> m) -> mono -> m
  - ofoldr1Ex :: (Element mono -> Element mono -> Element mono) -> mono -> Element mono
  - ofoldl1Ex' :: (Element mono -> Element mono -> Element mono) -> mono -> Element mono
  - headEx :: mono -> Element mono
  - lastEx :: mono -> Element mono
  - unsafeHead :: mono -> Element mono
  - unsafeLast :: mono -> Element mono
  - maximumByEx :: (Element mono -> Element mono -> Ordering) -> mono -> Element mono
  - minimumByEx :: (Element mono -> Element mono -> Ordering) -> mono -> Element mono
  - oelem :: Eq (Element mono) => Element mono -> mono -> Bool
  - onotElem :: Eq (Element mono) => Element mono -> mono -> Bool
- headMay :: MonoFoldable mono => mono -> Maybe (Element mono)
- lastMay :: MonoFoldable mono => mono -> Maybe (Element mono)
- osum :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
- oproduct :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono
- oand :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool
- oor :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool
- oconcatMap :: (MonoFoldable mono, Monoid m) => (Element mono -> m) -> mono -> m
- ofold :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
- oconcat :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono
- ofoldM :: (MonoFoldable mono, Monad m) => (a -> Element mono -> m a) -> a -> mono -> m a
- osequence_ :: (Applicative m, MonoFoldable mono, Element mono ~ m ()) => mono -> m ()
- maximumEx :: (MonoFoldable mono, Ord (Element mono)) => mono -> Element mono
- minimumEx :: (MonoFoldable mono, Ord (Element mono)) => mono -> Element mono
- maximumMay :: (MonoFoldable mono, Ord (Element mono)) => mono -> Maybe (Element mono)
- maximumByMay :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Maybe (Element mono)
- minimumMay :: (MonoFoldable mono, Ord (Element mono)) => mono -> Maybe (Element mono)
- minimumByMay :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Maybe (Element mono)
- class (MonoFunctor mono, MonoFoldable mono) => MonoTraversable mono where
  - otraverse :: Applicative f => (Element mono -> f (Element mono)) -> mono -> f mono
  - omapM :: Applicative m => (Element mono -> m (Element mono)) -> mono -> m mono
- ofor :: (MonoTraversable mono, Applicative f) => mono -> (Element mono -> f (Element mono)) -> f mono
- oforM :: (MonoTraversable mono, Applicative f) => mono -> (Element mono -> f (Element mono)) -> f mono
- ofoldlUnwrap :: MonoFoldable mono => (x -> Element mono -> x) -> x -> (x -> b) -> mono -> b
- ofoldMUnwrap :: (Monad m, MonoFoldable mono) => (x -> Element mono -> m x) -> m x -> (x -> m b) -> mono -> m b
- class MonoPointed mono where
  - opoint :: Element mono -> mono
- class MonoFunctor mono => MonoComonad mono where
  - oextract :: mono -> Element mono
  - oextend :: (mono -> Element mono) -> mono -> mono
- class MonoFoldable mono => GrowingAppend mono
- ointercalate :: (MonoFoldable mono, Monoid (Element mono)) => Element mono -> mono -> Element mono
- newtype WrappedPoly f a = WrappedPoly {
  - unwrapPoly :: f a
  }
- data WrappedMono mono a where
  - WrappedMono :: Element mono ~ a => mono -> WrappedMono mono a
- unwrapMono :: WrappedMono mono a -> mono

# Documentation

type family Element mono #

Type family for getting the type of the elements of a monomorphic container.

#### Instances

Instances details

type Element ByteString # |
Instance details Defined in Data.MonoTraversable type Element ByteString = Word8
type Element ByteString # |
Instance details Defined in Data.MonoTraversable type Element ByteString = Word8
type Element IntSet # |
Instance details Defined in Data.MonoTraversable type Element IntSet = Int
type Element Text # |
Instance details Defined in Data.MonoTraversable type Element Text = Char
type Element Text # |
Instance details Defined in Data.MonoTraversable type Element Text = Char
type Element (ZipList a) # |
Instance details Defined in Data.MonoTraversable type Element (ZipList a) = a
type Element (Identity a) # |
Instance details Defined in Data.MonoTraversable type Element (Identity a) = a
type Element (NonEmpty a) # |
Instance details Defined in Data.MonoTraversable type Element (NonEmpty a) = a
type Element (Par1 a) # |
Instance details Defined in Data.MonoTraversable type Element (Par1 a) = a
type Element (IntMap a) # |
Instance details Defined in Data.MonoTraversable type Element (IntMap a) = a
type Element (Seq a) # |
Instance details Defined in Data.MonoTraversable type Element (Seq a) = a
type Element (ViewL a) # |
Instance details Defined in Data.MonoTraversable type Element (ViewL a) = a
type Element (ViewR a) # |
Instance details Defined in Data.MonoTraversable type Element (ViewR a) = a
type Element (Set e) # |
Instance details Defined in Data.MonoTraversable type Element (Set e) = e
type Element (Tree a) # |
Instance details Defined in Data.MonoTraversable type Element (Tree a) = a
type Element (IO a) # |
Instance details Defined in Data.MonoTraversable type Element (IO a) = a
type Element (NonNull mono) # |
Instance details Defined in Data.NonNull type Element (NonNull mono) = Element mono
type Element (HashSet e) # |
Instance details Defined in Data.MonoTraversable type Element (HashSet e) = e
type Element (Vector a) # |
Instance details Defined in Data.MonoTraversable type Element (Vector a) = a
type Element (Vector a) # |
Instance details Defined in Data.MonoTraversable type Element (Vector a) = a
type Element (Vector a) # |
Instance details Defined in Data.MonoTraversable type Element (Vector a) = a
type Element (Maybe a) # |
Instance details Defined in Data.MonoTraversable type Element (Maybe a) = a
type Element [a] # |
Instance details Defined in Data.MonoTraversable type Element [a] = a
type Element (WrappedMonad m a) # |
Instance details Defined in Data.MonoTraversable type Element (WrappedMonad m a) = a
type Element (Either a b) # |
Instance details Defined in Data.MonoTraversable type Element (Either a b) = b
type Element (Proxy a) # |
Instance details Defined in Data.MonoTraversable type Element (Proxy a) = a
type Element (Arg a b) # |
Instance details Defined in Data.MonoTraversable type Element (Arg a b) = b
type Element (U1 a) # |
Instance details Defined in Data.MonoTraversable type Element (U1 a) = a
type Element (V1 a) # |
Instance details Defined in Data.MonoTraversable type Element (V1 a) = a
type Element (Map k v) # |
Instance details Defined in Data.MonoTraversable type Element (Map k v) = v
type Element (WrappedMono mono a) # |
Instance details Defined in Data.MonoTraversable type Element (WrappedMono mono a) = Element mono
type Element (WrappedPoly f a) # |
Instance details Defined in Data.MonoTraversable type Element (WrappedPoly f a) = a
type Element (MaybeT m a) # |
Instance details Defined in Data.MonoTraversable type Element (MaybeT m a) = a
type Element (HashMap k v) # |
Instance details Defined in Data.MonoTraversable type Element (HashMap k v) = v
type Element (a, b) # |
Instance details Defined in Data.MonoTraversable type Element (a, b) = b
type Element (r -> a) # |
Instance details Defined in Data.MonoTraversable type Element (r -> a) = a
type Element (WrappedArrow a b c) # |
Instance details Defined in Data.MonoTraversable type Element (WrappedArrow a b c) = c
type Element (Const m a) # |
Instance details Defined in Data.MonoTraversable type Element (Const m a) = a
type Element (Rec1 f a) # |
Instance details Defined in Data.MonoTraversable type Element (Rec1 f a) = a
type Element (IdentityT m a) # |
Instance details Defined in Data.MonoTraversable type Element (IdentityT m a) = a
type Element (ReaderT r m a) # |
Instance details Defined in Data.MonoTraversable type Element (ReaderT r m a) = a
type Element (StateT s m a) # |
Instance details Defined in Data.MonoTraversable type Element (StateT s m a) = a
type Element (StateT s m a) # |
Instance details Defined in Data.MonoTraversable type Element (StateT s m a) = a
type Element (WriterT w m a) # |
Instance details Defined in Data.MonoTraversable type Element (WriterT w m a) = a
type Element (WriterT w m a) # |
Instance details Defined in Data.MonoTraversable type Element (WriterT w m a) = a
type Element (Product f g a) # |
Instance details Defined in Data.MonoTraversable type Element (Product f g a) = a
type Element ((f :*: g) a) # |
Instance details Defined in Data.MonoTraversable type Element ((f :*: g) a) = a
type Element ((f :+: g) a) # |
Instance details Defined in Data.MonoTraversable type Element ((f :+: g) a) = a
type Element (K1 i c a) # |
Instance details Defined in Data.MonoTraversable type Element (K1 i c a) = a
type Element (ContT r m a) # |
Instance details Defined in Data.MonoTraversable type Element (ContT r m a) = a
type Element (Compose f g a) # |
Instance details Defined in Data.MonoTraversable type Element (Compose f g a) = a
type Element ((f :.: g) a) # |
Instance details Defined in Data.MonoTraversable type Element ((f :.: g) a) = a
type Element (M1 i c f a) # |
Instance details Defined in Data.MonoTraversable type Element (M1 i c f a) = a
type Element (RWST r w s m a) # |
Instance details Defined in Data.MonoTraversable type Element (RWST r w s m a) = a
type Element (RWST r w s m a) # |
Instance details Defined in Data.MonoTraversable type Element (RWST r w s m a) = a

class MonoFunctor mono where #

Monomorphic containers that can be mapped over.

Minimal complete definition

Nothing

Methods

omap :: (Element mono -> Element mono) -> mono -> mono #

Map over a monomorphic container

default omap :: (Functor f, Element (f a) ~ a, f a ~ mono) => (Element mono -> Element mono) -> mono -> mono #

#### Instances

Instances details

MonoFunctor ByteString # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element ByteString -> Element ByteString) -> ByteString -> ByteString #
MonoFunctor ByteString # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element ByteString -> Element ByteString) -> ByteString -> ByteString #
MonoFunctor Text # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element Text -> Element Text) -> Text -> Text #
MonoFunctor Text # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element Text -> Element Text) -> Text -> Text #
MonoFunctor (ZipList a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> ZipList a #
MonoFunctor (Identity a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Identity a) -> Element (Identity a)) -> Identity a -> Identity a #
MonoFunctor (NonEmpty a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> NonEmpty a #
MonoFunctor (Par1 a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Par1 a) -> Element (Par1 a)) -> Par1 a -> Par1 a #
MonoFunctor (IntMap a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (IntMap a) -> Element (IntMap a)) -> IntMap a -> IntMap a #
MonoFunctor (Seq a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Seq a) -> Element (Seq a)) -> Seq a -> Seq a #
MonoFunctor (ViewL a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (ViewL a) -> Element (ViewL a)) -> ViewL a -> ViewL a #
MonoFunctor (ViewR a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (ViewR a) -> Element (ViewR a)) -> ViewR a -> ViewR a #
MonoFunctor (Tree a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Tree a) -> Element (Tree a)) -> Tree a -> Tree a #
MonoFunctor (IO a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (IO a) -> Element (IO a)) -> IO a -> IO a #
MonoFunctor mono => MonoFunctor (NonNull mono) # |
Instance details Defined in Data.NonNull Methods omap :: (Element (NonNull mono) -> Element (NonNull mono)) -> NonNull mono -> NonNull mono #
MonoFunctor (Vector a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a #
Storable a => MonoFunctor (Vector a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a #
Unbox a => MonoFunctor (Vector a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a #
MonoFunctor (Maybe a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe a #
MonoFunctor [a] # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element [a] -> Element [a]) -> [a] -> [a] #
Monad m => MonoFunctor (WrappedMonad m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (WrappedMonad m a) -> Element (WrappedMonad m a)) -> WrappedMonad m a -> WrappedMonad m a #
MonoFunctor (Either a b) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Either a b) -> Element (Either a b)) -> Either a b -> Either a b #
MonoFunctor (Proxy a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Proxy a) -> Element (Proxy a)) -> Proxy a -> Proxy a #
MonoFunctor (Arg a b) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Arg a b) -> Element (Arg a b)) -> Arg a b -> Arg a b #
MonoFunctor (U1 a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (U1 a) -> Element (U1 a)) -> U1 a -> U1 a #
MonoFunctor (V1 a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (V1 a) -> Element (V1 a)) -> V1 a -> V1 a #
MonoFunctor (Map k v) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Map k v) -> Element (Map k v)) -> Map k v -> Map k v #
MonoFunctor mono => MonoFunctor (WrappedMono mono a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a)) -> WrappedMono mono a -> WrappedMono mono a #
Functor f => MonoFunctor (WrappedPoly f a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a)) -> WrappedPoly f a -> WrappedPoly f a #
Functor m => MonoFunctor (MaybeT m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (MaybeT m a) -> Element (MaybeT m a)) -> MaybeT m a -> MaybeT m a #
MonoFunctor (HashMap k v) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> HashMap k v #
MonoFunctor (a, b) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (a, b) -> Element (a, b)) -> (a, b) -> (a, b) #
MonoFunctor (r -> a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (r -> a) -> Element (r -> a)) -> (r -> a) -> r -> a #
Arrow a => MonoFunctor (WrappedArrow a b c) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (WrappedArrow a b c) -> Element (WrappedArrow a b c)) -> WrappedArrow a b c -> WrappedArrow a b c #
MonoFunctor (Const m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Const m a) -> Element (Const m a)) -> Const m a -> Const m a #
Functor f => MonoFunctor (Rec1 f a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Rec1 f a) -> Element (Rec1 f a)) -> Rec1 f a -> Rec1 f a #
Functor m => MonoFunctor (IdentityT m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (IdentityT m a) -> Element (IdentityT m a)) -> IdentityT m a -> IdentityT m a #
Functor m => MonoFunctor (ReaderT r m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (ReaderT r m a) -> Element (ReaderT r m a)) -> ReaderT r m a -> ReaderT r m a #
Functor m => MonoFunctor (StateT s m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (StateT s m a) -> Element (StateT s m a)) -> StateT s m a -> StateT s m a #
Functor m => MonoFunctor (StateT s m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (StateT s m a) -> Element (StateT s m a)) -> StateT s m a -> StateT s m a #
Functor m => MonoFunctor (WriterT w m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (WriterT w m a) -> Element (WriterT w m a)) -> WriterT w m a -> WriterT w m a #
Functor m => MonoFunctor (WriterT w m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (WriterT w m a) -> Element (WriterT w m a)) -> WriterT w m a -> WriterT w m a #
(Functor f, Functor g) => MonoFunctor (Product f g a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Product f g a) -> Element (Product f g a)) -> Product f g a -> Product f g a #
(Functor f, Functor g) => MonoFunctor ((f :*: g) a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element ((f :*: g) a) -> Element ((f :*: g) a)) -> (f :*: g) a -> (f :*: g) a #
(Functor f, Functor g) => MonoFunctor ((f :+: g) a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element ((f :+: g) a) -> Element ((f :+: g) a)) -> (f :+: g) a -> (f :+: g) a #
MonoFunctor (K1 i c a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (K1 i c a) -> Element (K1 i c a)) -> K1 i c a -> K1 i c a #
Functor m => MonoFunctor (ContT r m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (ContT r m a) -> Element (ContT r m a)) -> ContT r m a -> ContT r m a #
(Functor f, Functor g) => MonoFunctor (Compose f g a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (Compose f g a) -> Element (Compose f g a)) -> Compose f g a -> Compose f g a #
(Functor f, Functor g) => MonoFunctor ((f :.: g) a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element ((f :.: g) a) -> Element ((f :.: g) a)) -> (f :.: g) a -> (f :.: g) a #
Functor f => MonoFunctor (M1 i c f a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (M1 i c f a) -> Element (M1 i c f a)) -> M1 i c f a -> M1 i c f a #
Functor m => MonoFunctor (RWST r w s m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (RWST r w s m a) -> Element (RWST r w s m a)) -> RWST r w s m a -> RWST r w s m a #
Functor m => MonoFunctor (RWST r w s m a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (RWST r w s m a) -> Element (RWST r w s m a)) -> RWST r w s m a -> RWST r w s m a #

replaceElem :: (MonoFunctor mono, Eq (Element mono)) => Element mono -> Element mono -> mono -> mono #

``replaceElem` old new` replaces all `old` elements with `new`.

Since: 1.0.1

replaceElemStrictText :: Char -> Char -> Text -> Text #

replaceElemLazyText :: Char -> Char -> Text -> Text #

class MonoFoldable mono where #

Monomorphic containers that can be folded.

Minimal complete definition

Nothing

Methods

ofoldMap :: Monoid m => (Element mono -> m) -> mono -> m #

Map each element of a monomorphic container to a `Monoid` and combine the results.

default ofoldMap :: (t a ~ mono, a ~ Element (t a), Foldable t, Monoid m) => (Element mono -> m) -> mono -> m #

ofoldr :: (Element mono -> b -> b) -> b -> mono -> b #

Right-associative fold of a monomorphic container.

default ofoldr :: (t a ~ mono, a ~ Element (t a), Foldable t) => (Element mono -> b -> b) -> b -> mono -> b #

ofoldl' :: (a -> Element mono -> a) -> a -> mono -> a #

Strict left-associative fold of a monomorphic container.

default ofoldl' :: (t b ~ mono, b ~ Element (t b), Foldable t) => (a -> Element mono -> a) -> a -> mono -> a #

otoList :: mono -> [Element mono] #

Convert a monomorphic container to a list.

oall :: (Element mono -> Bool) -> mono -> Bool #

Are all of the elements in a monomorphic container converted to booleans `True`?

oany :: (Element mono -> Bool) -> mono -> Bool #

Are any of the elements in a monomorphic container converted to booleans `True`?

onull :: mono -> Bool #

Is the monomorphic container empty?

olength :: mono -> Int #

Length of a monomorphic container, returns a `Int`.

olength64 :: mono -> Int64 #

Length of a monomorphic container, returns a `Int64`.

ocompareLength :: Integral i => mono -> i -> Ordering #

Compare the length of a monomorphic container and a given number.

otraverse_ :: Applicative f => (Element mono -> f b) -> mono -> f () #

Map each element of a monomorphic container to an action, evaluate these actions from left to right, and ignore the results.

ofor_ :: Applicative f => mono -> (Element mono -> f b) -> f () #

`ofor_` is `otraverse_` with its arguments flipped.

omapM_ :: Applicative m => (Element mono -> m ()) -> mono -> m () #

Map each element of a monomorphic container to a monadic action, evaluate these actions from left to right, and ignore the results.

oforM_ :: Applicative m => mono -> (Element mono -> m ()) -> m () #

`oforM_` is `omapM_` with its arguments flipped.

ofoldlM :: Monad m => (a -> Element mono -> m a) -> a -> mono -> m a #

Monadic fold over the elements of a monomorphic container, associating to the left.

ofoldMap1Ex :: Semigroup m => (Element mono -> m) -> mono -> m #

Map each element of a monomorphic container to a semigroup, and combine the results.

Note: this is a partial function. On an empty `MonoFoldable`, it will throw an exception.

See `ofoldMap1` from Data.NonNull for a total version of this function.

ofoldr1Ex :: (Element mono -> Element mono -> Element mono) -> mono -> Element mono #

Right-associative fold of a monomorphic container with no base element.

Note: this is a partial function. On an empty `MonoFoldable`, it will throw an exception.

See `ofoldr1` from Data.NonNull for a total version of this function.

default ofoldr1Ex :: (t a ~ mono, a ~ Element (t a), Foldable t) => (Element mono -> Element mono -> Element mono) -> mono -> Element mono #

ofoldl1Ex' :: (Element mono -> Element mono -> Element mono) -> mono -> Element mono #

Strict left-associative fold of a monomorphic container with no base element.

Note: this is a partial function. On an empty `MonoFoldable`, it will throw an exception.

See `ofoldl1'` from Data.NonNull for a total version of this function.

default ofoldl1Ex' :: (t a ~ mono, a ~ Element (t a), Foldable t) => (Element mono -> Element mono -> Element mono) -> mono -> Element mono #

headEx :: mono -> Element mono #

Get the first element of a monomorphic container.

Note: this is a partial function. On an empty `MonoFoldable`, it will throw an exception.

See `head` from Data.NonNull for a total version of this function.

lastEx :: mono -> Element mono #

Get the last element of a monomorphic container.

Note: this is a partial function. On an empty `MonoFoldable`, it will throw an exception.

See `last` from Data.NonNull for a total version of this function.

unsafeHead :: mono -> Element mono #

Equivalent to `headEx`.

unsafeLast :: mono -> Element mono #

Equivalent to `lastEx`.

maximumByEx :: (Element mono -> Element mono -> Ordering) -> mono -> Element mono #

Get the maximum element of a monomorphic container, using a supplied element ordering function.

Note: this is a partial function. On an empty `MonoFoldable`, it will throw an exception.

See `maximiumBy` from Data.NonNull for a total version of this function.

minimumByEx :: (Element mono -> Element mono -> Ordering) -> mono -> Element mono #

Get the minimum element of a monomorphic container, using a supplied element ordering function.

Note: this is a partial function. On an empty `MonoFoldable`, it will throw an exception.

See `minimumBy` from Data.NonNull for a total version of this function.

oelem :: Eq (Element mono) => Element mono -> mono -> Bool #

Checks if the monomorphic container includes the supplied element.

onotElem :: Eq (Element mono) => Element mono -> mono -> Bool #

Checks if the monomorphic container does not include the supplied element.

#### Instances

Instances details

MonoFoldable ByteString # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element ByteString -> m) -> ByteString -> m #

ofoldr :: (Element ByteString -> b -> b) -> b -> ByteString -> b #

ofoldl' :: (a -> Element ByteString -> a) -> a -> ByteString -> a #

otoList :: ByteString -> [Element ByteString] #

oall :: (Element ByteString -> Bool) -> ByteString -> Bool #

oany :: (Element ByteString -> Bool) -> ByteString -> Bool #

onull :: ByteString -> Bool #

olength :: ByteString -> Int #

olength64 :: ByteString -> Int64 #

ocompareLength :: Integral i => ByteString -> i -> Ordering #

otraverse_ :: Applicative f => (Element ByteString -> f b) -> ByteString -> f () #

ofor_ :: Applicative f => ByteString -> (Element ByteString -> f b) -> f () #

omapM_ :: Applicative m => (Element ByteString -> m ()) -> ByteString -> m () #

oforM_ :: Applicative m => ByteString -> (Element ByteString -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element ByteString -> m a) -> a -> ByteString -> m a #

ofoldMap1Ex :: Semigroup m => (Element ByteString -> m) -> ByteString -> m #

ofoldr1Ex :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Element ByteString #

ofoldl1Ex' :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Element ByteString #

headEx :: ByteString -> Element ByteString #

lastEx :: ByteString -> Element ByteString #

unsafeHead :: ByteString -> Element ByteString #

unsafeLast :: ByteString -> Element ByteString #

maximumByEx :: (Element ByteString -> Element ByteString -> Ordering) -> ByteString -> Element ByteString #

minimumByEx :: (Element ByteString -> Element ByteString -> Ordering) -> ByteString -> Element ByteString #

oelem :: Element ByteString -> ByteString -> Bool #

onotElem :: Element ByteString -> ByteString -> Bool #

MonoFoldable ByteString # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element ByteString -> m) -> ByteString -> m #

ofoldr :: (Element ByteString -> b -> b) -> b -> ByteString -> b #

ofoldl' :: (a -> Element ByteString -> a) -> a -> ByteString -> a #

otoList :: ByteString -> [Element ByteString] #

oall :: (Element ByteString -> Bool) -> ByteString -> Bool #

oany :: (Element ByteString -> Bool) -> ByteString -> Bool #

onull :: ByteString -> Bool #

olength :: ByteString -> Int #

olength64 :: ByteString -> Int64 #

ocompareLength :: Integral i => ByteString -> i -> Ordering #

otraverse_ :: Applicative f => (Element ByteString -> f b) -> ByteString -> f () #

ofor_ :: Applicative f => ByteString -> (Element ByteString -> f b) -> f () #

omapM_ :: Applicative m => (Element ByteString -> m ()) -> ByteString -> m () #

oforM_ :: Applicative m => ByteString -> (Element ByteString -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element ByteString -> m a) -> a -> ByteString -> m a #

ofoldMap1Ex :: Semigroup m => (Element ByteString -> m) -> ByteString -> m #

ofoldr1Ex :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Element ByteString #

ofoldl1Ex' :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Element ByteString #

headEx :: ByteString -> Element ByteString #

lastEx :: ByteString -> Element ByteString #

unsafeHead :: ByteString -> Element ByteString #

unsafeLast :: ByteString -> Element ByteString #

maximumByEx :: (Element ByteString -> Element ByteString -> Ordering) -> ByteString -> Element ByteString #

minimumByEx :: (Element ByteString -> Element ByteString -> Ordering) -> ByteString -> Element ByteString #

oelem :: Element ByteString -> ByteString -> Bool #

onotElem :: Element ByteString -> ByteString -> Bool #

MonoFoldable IntSet # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element IntSet -> m) -> IntSet -> m #

ofoldr :: (Element IntSet -> b -> b) -> b -> IntSet -> b #

ofoldl' :: (a -> Element IntSet -> a) -> a -> IntSet -> a #

otoList :: IntSet -> [Element IntSet] #

oall :: (Element IntSet -> Bool) -> IntSet -> Bool #

oany :: (Element IntSet -> Bool) -> IntSet -> Bool #

onull :: IntSet -> Bool #

olength :: IntSet -> Int #

olength64 :: IntSet -> Int64 #

ocompareLength :: Integral i => IntSet -> i -> Ordering #

otraverse_ :: Applicative f => (Element IntSet -> f b) -> IntSet -> f () #

ofor_ :: Applicative f => IntSet -> (Element IntSet -> f b) -> f () #

omapM_ :: Applicative m => (Element IntSet -> m ()) -> IntSet -> m () #

oforM_ :: Applicative m => IntSet -> (Element IntSet -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element IntSet -> m a) -> a -> IntSet -> m a #

ofoldMap1Ex :: Semigroup m => (Element IntSet -> m) -> IntSet -> m #

ofoldr1Ex :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Element IntSet #

ofoldl1Ex' :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Element IntSet #

headEx :: IntSet -> Element IntSet #

lastEx :: IntSet -> Element IntSet #

unsafeHead :: IntSet -> Element IntSet #

unsafeLast :: IntSet -> Element IntSet #

maximumByEx :: (Element IntSet -> Element IntSet -> Ordering) -> IntSet -> Element IntSet #

minimumByEx :: (Element IntSet -> Element IntSet -> Ordering) -> IntSet -> Element IntSet #

oelem :: Element IntSet -> IntSet -> Bool #

onotElem :: Element IntSet -> IntSet -> Bool #

MonoFoldable Text # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element Text -> m) -> Text -> m #

ofoldr :: (Element Text -> b -> b) -> b -> Text -> b #

ofoldl' :: (a -> Element Text -> a) -> a -> Text -> a #

otoList :: Text -> [Element Text] #

oall :: (Element Text -> Bool) -> Text -> Bool #

oany :: (Element Text -> Bool) -> Text -> Bool #

onull :: Text -> Bool #

olength :: Text -> Int #

olength64 :: Text -> Int64 #

ocompareLength :: Integral i => Text -> i -> Ordering #

otraverse_ :: Applicative f => (Element Text -> f b) -> Text -> f () #

ofor_ :: Applicative f => Text -> (Element Text -> f b) -> f () #

omapM_ :: Applicative m => (Element Text -> m ()) -> Text -> m () #

oforM_ :: Applicative m => Text -> (Element Text -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element Text -> m a) -> a -> Text -> m a #

ofoldMap1Ex :: Semigroup m => (Element Text -> m) -> Text -> m #

ofoldr1Ex :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text #

ofoldl1Ex' :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text #

headEx :: Text -> Element Text #

lastEx :: Text -> Element Text #

unsafeHead :: Text -> Element Text #

unsafeLast :: Text -> Element Text #

maximumByEx :: (Element Text -> Element Text -> Ordering) -> Text -> Element Text #

minimumByEx :: (Element Text -> Element Text -> Ordering) -> Text -> Element Text #

oelem :: Element Text -> Text -> Bool #

onotElem :: Element Text -> Text -> Bool #

MonoFoldable Text # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element Text -> m) -> Text -> m #

ofoldr :: (Element Text -> b -> b) -> b -> Text -> b #

ofoldl' :: (a -> Element Text -> a) -> a -> Text -> a #

otoList :: Text -> [Element Text] #

oall :: (Element Text -> Bool) -> Text -> Bool #

oany :: (Element Text -> Bool) -> Text -> Bool #

onull :: Text -> Bool #

olength :: Text -> Int #

olength64 :: Text -> Int64 #

ocompareLength :: Integral i => Text -> i -> Ordering #

otraverse_ :: Applicative f => (Element Text -> f b) -> Text -> f () #

ofor_ :: Applicative f => Text -> (Element Text -> f b) -> f () #

omapM_ :: Applicative m => (Element Text -> m ()) -> Text -> m () #

oforM_ :: Applicative m => Text -> (Element Text -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element Text -> m a) -> a -> Text -> m a #

ofoldMap1Ex :: Semigroup m => (Element Text -> m) -> Text -> m #

ofoldr1Ex :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text #

ofoldl1Ex' :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text #

headEx :: Text -> Element Text #

lastEx :: Text -> Element Text #

unsafeHead :: Text -> Element Text #

unsafeLast :: Text -> Element Text #

maximumByEx :: (Element Text -> Element Text -> Ordering) -> Text -> Element Text #

minimumByEx :: (Element Text -> Element Text -> Ordering) -> Text -> Element Text #

oelem :: Element Text -> Text -> Bool #

onotElem :: Element Text -> Text -> Bool #

MonoFoldable (Identity a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Identity a) -> m) -> Identity a -> m #

ofoldr :: (Element (Identity a) -> b -> b) -> b -> Identity a -> b #

ofoldl' :: (a0 -> Element (Identity a) -> a0) -> a0 -> Identity a -> a0 #

otoList :: Identity a -> [Element (Identity a)] #

oall :: (Element (Identity a) -> Bool) -> Identity a -> Bool #

oany :: (Element (Identity a) -> Bool) -> Identity a -> Bool #

onull :: Identity a -> Bool #

olength :: Identity a -> Int #

olength64 :: Identity a -> Int64 #

ocompareLength :: Integral i => Identity a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Identity a) -> f b) -> Identity a -> f () #

ofor_ :: Applicative f => Identity a -> (Element (Identity a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Identity a) -> m ()) -> Identity a -> m () #

oforM_ :: Applicative m => Identity a -> (Element (Identity a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Identity a) -> m a0) -> a0 -> Identity a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Identity a) -> m) -> Identity a -> m #

ofoldr1Ex :: (Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Element (Identity a) #

ofoldl1Ex' :: (Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Element (Identity a) #

headEx :: Identity a -> Element (Identity a) #

lastEx :: Identity a -> Element (Identity a) #

unsafeHead :: Identity a -> Element (Identity a) #

unsafeLast :: Identity a -> Element (Identity a) #

maximumByEx :: (Element (Identity a) -> Element (Identity a) -> Ordering) -> Identity a -> Element (Identity a) #

minimumByEx :: (Element (Identity a) -> Element (Identity a) -> Ordering) -> Identity a -> Element (Identity a) #

oelem :: Element (Identity a) -> Identity a -> Bool #

onotElem :: Element (Identity a) -> Identity a -> Bool #

MonoFoldable (NonEmpty a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (NonEmpty a) -> m) -> NonEmpty a -> m #

ofoldr :: (Element (NonEmpty a) -> b -> b) -> b -> NonEmpty a -> b #

ofoldl' :: (a0 -> Element (NonEmpty a) -> a0) -> a0 -> NonEmpty a -> a0 #

otoList :: NonEmpty a -> [Element (NonEmpty a)] #

oall :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool #

oany :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool #

onull :: NonEmpty a -> Bool #

olength :: NonEmpty a -> Int #

olength64 :: NonEmpty a -> Int64 #

ocompareLength :: Integral i => NonEmpty a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (NonEmpty a) -> f b) -> NonEmpty a -> f () #

ofor_ :: Applicative f => NonEmpty a -> (Element (NonEmpty a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (NonEmpty a) -> m ()) -> NonEmpty a -> m () #

oforM_ :: Applicative m => NonEmpty a -> (Element (NonEmpty a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (NonEmpty a) -> m a0) -> a0 -> NonEmpty a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (NonEmpty a) -> m) -> NonEmpty a -> m #

ofoldr1Ex :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Element (NonEmpty a) #

ofoldl1Ex' :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Element (NonEmpty a) #

headEx :: NonEmpty a -> Element (NonEmpty a) #

lastEx :: NonEmpty a -> Element (NonEmpty a) #

unsafeHead :: NonEmpty a -> Element (NonEmpty a) #

unsafeLast :: NonEmpty a -> Element (NonEmpty a) #

maximumByEx :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Ordering) -> NonEmpty a -> Element (NonEmpty a) #

minimumByEx :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Ordering) -> NonEmpty a -> Element (NonEmpty a) #

oelem :: Element (NonEmpty a) -> NonEmpty a -> Bool #

onotElem :: Element (NonEmpty a) -> NonEmpty a -> Bool #

MonoFoldable (Par1 a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Par1 a) -> m) -> Par1 a -> m #

ofoldr :: (Element (Par1 a) -> b -> b) -> b -> Par1 a -> b #

ofoldl' :: (a0 -> Element (Par1 a) -> a0) -> a0 -> Par1 a -> a0 #

otoList :: Par1 a -> [Element (Par1 a)] #

oall :: (Element (Par1 a) -> Bool) -> Par1 a -> Bool #

oany :: (Element (Par1 a) -> Bool) -> Par1 a -> Bool #

onull :: Par1 a -> Bool #

olength :: Par1 a -> Int #

olength64 :: Par1 a -> Int64 #

ocompareLength :: Integral i => Par1 a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Par1 a) -> f b) -> Par1 a -> f () #

ofor_ :: Applicative f => Par1 a -> (Element (Par1 a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Par1 a) -> m ()) -> Par1 a -> m () #

oforM_ :: Applicative m => Par1 a -> (Element (Par1 a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Par1 a) -> m a0) -> a0 -> Par1 a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Par1 a) -> m) -> Par1 a -> m #

ofoldr1Ex :: (Element (Par1 a) -> Element (Par1 a) -> Element (Par1 a)) -> Par1 a -> Element (Par1 a) #

ofoldl1Ex' :: (Element (Par1 a) -> Element (Par1 a) -> Element (Par1 a)) -> Par1 a -> Element (Par1 a) #

headEx :: Par1 a -> Element (Par1 a) #

lastEx :: Par1 a -> Element (Par1 a) #

unsafeHead :: Par1 a -> Element (Par1 a) #

unsafeLast :: Par1 a -> Element (Par1 a) #

maximumByEx :: (Element (Par1 a) -> Element (Par1 a) -> Ordering) -> Par1 a -> Element (Par1 a) #

minimumByEx :: (Element (Par1 a) -> Element (Par1 a) -> Ordering) -> Par1 a -> Element (Par1 a) #

oelem :: Element (Par1 a) -> Par1 a -> Bool #

onotElem :: Element (Par1 a) -> Par1 a -> Bool #

MonoFoldable (IntMap a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (IntMap a) -> m) -> IntMap a -> m #

ofoldr :: (Element (IntMap a) -> b -> b) -> b -> IntMap a -> b #

ofoldl' :: (a0 -> Element (IntMap a) -> a0) -> a0 -> IntMap a -> a0 #

otoList :: IntMap a -> [Element (IntMap a)] #

oall :: (Element (IntMap a) -> Bool) -> IntMap a -> Bool #

oany :: (Element (IntMap a) -> Bool) -> IntMap a -> Bool #

onull :: IntMap a -> Bool #

olength :: IntMap a -> Int #

olength64 :: IntMap a -> Int64 #

ocompareLength :: Integral i => IntMap a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (IntMap a) -> f b) -> IntMap a -> f () #

ofor_ :: Applicative f => IntMap a -> (Element (IntMap a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (IntMap a) -> m ()) -> IntMap a -> m () #

oforM_ :: Applicative m => IntMap a -> (Element (IntMap a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (IntMap a) -> m a0) -> a0 -> IntMap a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (IntMap a) -> m) -> IntMap a -> m #

ofoldr1Ex :: (Element (IntMap a) -> Element (IntMap a) -> Element (IntMap a)) -> IntMap a -> Element (IntMap a) #

ofoldl1Ex' :: (Element (IntMap a) -> Element (IntMap a) -> Element (IntMap a)) -> IntMap a -> Element (IntMap a) #

headEx :: IntMap a -> Element (IntMap a) #

lastEx :: IntMap a -> Element (IntMap a) #

unsafeHead :: IntMap a -> Element (IntMap a) #

unsafeLast :: IntMap a -> Element (IntMap a) #

maximumByEx :: (Element (IntMap a) -> Element (IntMap a) -> Ordering) -> IntMap a -> Element (IntMap a) #

minimumByEx :: (Element (IntMap a) -> Element (IntMap a) -> Ordering) -> IntMap a -> Element (IntMap a) #

oelem :: Element (IntMap a) -> IntMap a -> Bool #

onotElem :: Element (IntMap a) -> IntMap a -> Bool #

MonoFoldable (Seq a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Seq a) -> m) -> Seq a -> m #

ofoldr :: (Element (Seq a) -> b -> b) -> b -> Seq a -> b #

ofoldl' :: (a0 -> Element (Seq a) -> a0) -> a0 -> Seq a -> a0 #

otoList :: Seq a -> [Element (Seq a)] #

oall :: (Element (Seq a) -> Bool) -> Seq a -> Bool #

oany :: (Element (Seq a) -> Bool) -> Seq a -> Bool #

onull :: Seq a -> Bool #

olength :: Seq a -> Int #

olength64 :: Seq a -> Int64 #

ocompareLength :: Integral i => Seq a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Seq a) -> f b) -> Seq a -> f () #

ofor_ :: Applicative f => Seq a -> (Element (Seq a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Seq a) -> m ()) -> Seq a -> m () #

oforM_ :: Applicative m => Seq a -> (Element (Seq a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Seq a) -> m a0) -> a0 -> Seq a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Seq a) -> m) -> Seq a -> m #

ofoldr1Ex :: (Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Element (Seq a) #

ofoldl1Ex' :: (Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Element (Seq a) #

headEx :: Seq a -> Element (Seq a) #

lastEx :: Seq a -> Element (Seq a) #

unsafeHead :: Seq a -> Element (Seq a) #

unsafeLast :: Seq a -> Element (Seq a) #

maximumByEx :: (Element (Seq a) -> Element (Seq a) -> Ordering) -> Seq a -> Element (Seq a) #

minimumByEx :: (Element (Seq a) -> Element (Seq a) -> Ordering) -> Seq a -> Element (Seq a) #

oelem :: Element (Seq a) -> Seq a -> Bool #

onotElem :: Element (Seq a) -> Seq a -> Bool #

MonoFoldable (ViewL a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (ViewL a) -> m) -> ViewL a -> m #

ofoldr :: (Element (ViewL a) -> b -> b) -> b -> ViewL a -> b #

ofoldl' :: (a0 -> Element (ViewL a) -> a0) -> a0 -> ViewL a -> a0 #

otoList :: ViewL a -> [Element (ViewL a)] #

oall :: (Element (ViewL a) -> Bool) -> ViewL a -> Bool #

oany :: (Element (ViewL a) -> Bool) -> ViewL a -> Bool #

onull :: ViewL a -> Bool #

olength :: ViewL a -> Int #

olength64 :: ViewL a -> Int64 #

ocompareLength :: Integral i => ViewL a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (ViewL a) -> f b) -> ViewL a -> f () #

ofor_ :: Applicative f => ViewL a -> (Element (ViewL a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (ViewL a) -> m ()) -> ViewL a -> m () #

oforM_ :: Applicative m => ViewL a -> (Element (ViewL a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (ViewL a) -> m a0) -> a0 -> ViewL a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (ViewL a) -> m) -> ViewL a -> m #

ofoldr1Ex :: (Element (ViewL a) -> Element (ViewL a) -> Element (ViewL a)) -> ViewL a -> Element (ViewL a) #

ofoldl1Ex' :: (Element (ViewL a) -> Element (ViewL a) -> Element (ViewL a)) -> ViewL a -> Element (ViewL a) #

headEx :: ViewL a -> Element (ViewL a) #

lastEx :: ViewL a -> Element (ViewL a) #

unsafeHead :: ViewL a -> Element (ViewL a) #

unsafeLast :: ViewL a -> Element (ViewL a) #

maximumByEx :: (Element (ViewL a) -> Element (ViewL a) -> Ordering) -> ViewL a -> Element (ViewL a) #

minimumByEx :: (Element (ViewL a) -> Element (ViewL a) -> Ordering) -> ViewL a -> Element (ViewL a) #

oelem :: Element (ViewL a) -> ViewL a -> Bool #

onotElem :: Element (ViewL a) -> ViewL a -> Bool #

MonoFoldable (ViewR a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (ViewR a) -> m) -> ViewR a -> m #

ofoldr :: (Element (ViewR a) -> b -> b) -> b -> ViewR a -> b #

ofoldl' :: (a0 -> Element (ViewR a) -> a0) -> a0 -> ViewR a -> a0 #

otoList :: ViewR a -> [Element (ViewR a)] #

oall :: (Element (ViewR a) -> Bool) -> ViewR a -> Bool #

oany :: (Element (ViewR a) -> Bool) -> ViewR a -> Bool #

onull :: ViewR a -> Bool #

olength :: ViewR a -> Int #

olength64 :: ViewR a -> Int64 #

ocompareLength :: Integral i => ViewR a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (ViewR a) -> f b) -> ViewR a -> f () #

ofor_ :: Applicative f => ViewR a -> (Element (ViewR a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (ViewR a) -> m ()) -> ViewR a -> m () #

oforM_ :: Applicative m => ViewR a -> (Element (ViewR a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (ViewR a) -> m a0) -> a0 -> ViewR a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (ViewR a) -> m) -> ViewR a -> m #

ofoldr1Ex :: (Element (ViewR a) -> Element (ViewR a) -> Element (ViewR a)) -> ViewR a -> Element (ViewR a) #

ofoldl1Ex' :: (Element (ViewR a) -> Element (ViewR a) -> Element (ViewR a)) -> ViewR a -> Element (ViewR a) #

headEx :: ViewR a -> Element (ViewR a) #

lastEx :: ViewR a -> Element (ViewR a) #

unsafeHead :: ViewR a -> Element (ViewR a) #

unsafeLast :: ViewR a -> Element (ViewR a) #

maximumByEx :: (Element (ViewR a) -> Element (ViewR a) -> Ordering) -> ViewR a -> Element (ViewR a) #

minimumByEx :: (Element (ViewR a) -> Element (ViewR a) -> Ordering) -> ViewR a -> Element (ViewR a) #

oelem :: Element (ViewR a) -> ViewR a -> Bool #

onotElem :: Element (ViewR a) -> ViewR a -> Bool #

Ord e => MonoFoldable (Set e) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Set e) -> m) -> Set e -> m #

ofoldr :: (Element (Set e) -> b -> b) -> b -> Set e -> b #

ofoldl' :: (a -> Element (Set e) -> a) -> a -> Set e -> a #

otoList :: Set e -> [Element (Set e)] #

oall :: (Element (Set e) -> Bool) -> Set e -> Bool #

oany :: (Element (Set e) -> Bool) -> Set e -> Bool #

onull :: Set e -> Bool #

olength :: Set e -> Int #

olength64 :: Set e -> Int64 #

ocompareLength :: Integral i => Set e -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Set e) -> f b) -> Set e -> f () #

ofor_ :: Applicative f => Set e -> (Element (Set e) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Set e) -> m ()) -> Set e -> m () #

oforM_ :: Applicative m => Set e -> (Element (Set e) -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element (Set e) -> m a) -> a -> Set e -> m a #

ofoldMap1Ex :: Semigroup m => (Element (Set e) -> m) -> Set e -> m #

ofoldr1Ex :: (Element (Set e) -> Element (Set e) -> Element (Set e)) -> Set e -> Element (Set e) #

ofoldl1Ex' :: (Element (Set e) -> Element (Set e) -> Element (Set e)) -> Set e -> Element (Set e) #

headEx :: Set e -> Element (Set e) #

lastEx :: Set e -> Element (Set e) #

unsafeHead :: Set e -> Element (Set e) #

unsafeLast :: Set e -> Element (Set e) #

maximumByEx :: (Element (Set e) -> Element (Set e) -> Ordering) -> Set e -> Element (Set e) #

minimumByEx :: (Element (Set e) -> Element (Set e) -> Ordering) -> Set e -> Element (Set e) #

oelem :: Element (Set e) -> Set e -> Bool #

onotElem :: Element (Set e) -> Set e -> Bool #

MonoFoldable (Tree a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Tree a) -> m) -> Tree a -> m #

ofoldr :: (Element (Tree a) -> b -> b) -> b -> Tree a -> b #

ofoldl' :: (a0 -> Element (Tree a) -> a0) -> a0 -> Tree a -> a0 #

otoList :: Tree a -> [Element (Tree a)] #

oall :: (Element (Tree a) -> Bool) -> Tree a -> Bool #

oany :: (Element (Tree a) -> Bool) -> Tree a -> Bool #

onull :: Tree a -> Bool #

olength :: Tree a -> Int #

olength64 :: Tree a -> Int64 #

ocompareLength :: Integral i => Tree a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Tree a) -> f b) -> Tree a -> f () #

ofor_ :: Applicative f => Tree a -> (Element (Tree a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Tree a) -> m ()) -> Tree a -> m () #

oforM_ :: Applicative m => Tree a -> (Element (Tree a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Tree a) -> m a0) -> a0 -> Tree a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Tree a) -> m) -> Tree a -> m #

ofoldr1Ex :: (Element (Tree a) -> Element (Tree a) -> Element (Tree a)) -> Tree a -> Element (Tree a) #

ofoldl1Ex' :: (Element (Tree a) -> Element (Tree a) -> Element (Tree a)) -> Tree a -> Element (Tree a) #

headEx :: Tree a -> Element (Tree a) #

lastEx :: Tree a -> Element (Tree a) #

unsafeHead :: Tree a -> Element (Tree a) #

unsafeLast :: Tree a -> Element (Tree a) #

maximumByEx :: (Element (Tree a) -> Element (Tree a) -> Ordering) -> Tree a -> Element (Tree a) #

minimumByEx :: (Element (Tree a) -> Element (Tree a) -> Ordering) -> Tree a -> Element (Tree a) #

oelem :: Element (Tree a) -> Tree a -> Bool #

onotElem :: Element (Tree a) -> Tree a -> Bool #

MonoFoldable mono => MonoFoldable (NonNull mono) # |

Instance details

Defined in Data.NonNull

Methods

ofoldMap :: Monoid m => (Element (NonNull mono) -> m) -> NonNull mono -> m #

ofoldr :: (Element (NonNull mono) -> b -> b) -> b -> NonNull mono -> b #

ofoldl' :: (a -> Element (NonNull mono) -> a) -> a -> NonNull mono -> a #

otoList :: NonNull mono -> [Element (NonNull mono)] #

oall :: (Element (NonNull mono) -> Bool) -> NonNull mono -> Bool #

oany :: (Element (NonNull mono) -> Bool) -> NonNull mono -> Bool #

onull :: NonNull mono -> Bool #

olength :: NonNull mono -> Int #

olength64 :: NonNull mono -> Int64 #

ocompareLength :: Integral i => NonNull mono -> i -> Ordering #

otraverse_ :: Applicative f => (Element (NonNull mono) -> f b) -> NonNull mono -> f () #

ofor_ :: Applicative f => NonNull mono -> (Element (NonNull mono) -> f b) -> f () #

omapM_ :: Applicative m => (Element (NonNull mono) -> m ()) -> NonNull mono -> m () #

oforM_ :: Applicative m => NonNull mono -> (Element (NonNull mono) -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element (NonNull mono) -> m a) -> a -> NonNull mono -> m a #

ofoldMap1Ex :: Semigroup m => (Element (NonNull mono) -> m) -> NonNull mono -> m #

ofoldr1Ex :: (Element (NonNull mono) -> Element (NonNull mono) -> Element (NonNull mono)) -> NonNull mono -> Element (NonNull mono) #

ofoldl1Ex' :: (Element (NonNull mono) -> Element (NonNull mono) -> Element (NonNull mono)) -> NonNull mono -> Element (NonNull mono) #

headEx :: NonNull mono -> Element (NonNull mono) #

lastEx :: NonNull mono -> Element (NonNull mono) #

unsafeHead :: NonNull mono -> Element (NonNull mono) #

unsafeLast :: NonNull mono -> Element (NonNull mono) #

maximumByEx :: (Element (NonNull mono) -> Element (NonNull mono) -> Ordering) -> NonNull mono -> Element (NonNull mono) #

minimumByEx :: (Element (NonNull mono) -> Element (NonNull mono) -> Ordering) -> NonNull mono -> Element (NonNull mono) #

oelem :: Element (NonNull mono) -> NonNull mono -> Bool #

onotElem :: Element (NonNull mono) -> NonNull mono -> Bool #

MonoFoldable (HashSet e) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (HashSet e) -> m) -> HashSet e -> m #

ofoldr :: (Element (HashSet e) -> b -> b) -> b -> HashSet e -> b #

ofoldl' :: (a -> Element (HashSet e) -> a) -> a -> HashSet e -> a #

otoList :: HashSet e -> [Element (HashSet e)] #

oall :: (Element (HashSet e) -> Bool) -> HashSet e -> Bool #

oany :: (Element (HashSet e) -> Bool) -> HashSet e -> Bool #

onull :: HashSet e -> Bool #

olength :: HashSet e -> Int #

olength64 :: HashSet e -> Int64 #

ocompareLength :: Integral i => HashSet e -> i -> Ordering #

otraverse_ :: Applicative f => (Element (HashSet e) -> f b) -> HashSet e -> f () #

ofor_ :: Applicative f => HashSet e -> (Element (HashSet e) -> f b) -> f () #

omapM_ :: Applicative m => (Element (HashSet e) -> m ()) -> HashSet e -> m () #

oforM_ :: Applicative m => HashSet e -> (Element (HashSet e) -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element (HashSet e) -> m a) -> a -> HashSet e -> m a #

ofoldMap1Ex :: Semigroup m => (Element (HashSet e) -> m) -> HashSet e -> m #

ofoldr1Ex :: (Element (HashSet e) -> Element (HashSet e) -> Element (HashSet e)) -> HashSet e -> Element (HashSet e) #

ofoldl1Ex' :: (Element (HashSet e) -> Element (HashSet e) -> Element (HashSet e)) -> HashSet e -> Element (HashSet e) #

headEx :: HashSet e -> Element (HashSet e) #

lastEx :: HashSet e -> Element (HashSet e) #

unsafeHead :: HashSet e -> Element (HashSet e) #

unsafeLast :: HashSet e -> Element (HashSet e) #

maximumByEx :: (Element (HashSet e) -> Element (HashSet e) -> Ordering) -> HashSet e -> Element (HashSet e) #

minimumByEx :: (Element (HashSet e) -> Element (HashSet e) -> Ordering) -> HashSet e -> Element (HashSet e) #

oelem :: Element (HashSet e) -> HashSet e -> Bool #

onotElem :: Element (HashSet e) -> HashSet e -> Bool #

MonoFoldable (Vector a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m #

ofoldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b #

ofoldl' :: (a0 -> Element (Vector a) -> a0) -> a0 -> Vector a -> a0 #

otoList :: Vector a -> [Element (Vector a)] #

oall :: (Element (Vector a) -> Bool) -> Vector a -> Bool #

oany :: (Element (Vector a) -> Bool) -> Vector a -> Bool #

onull :: Vector a -> Bool #

olength :: Vector a -> Int #

olength64 :: Vector a -> Int64 #

ocompareLength :: Integral i => Vector a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Vector a) -> f b) -> Vector a -> f () #

ofor_ :: Applicative f => Vector a -> (Element (Vector a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Vector a) -> m ()) -> Vector a -> m () #

oforM_ :: Applicative m => Vector a -> (Element (Vector a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Vector a) -> m a0) -> a0 -> Vector a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Vector a) -> m) -> Vector a -> m #

ofoldr1Ex :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Element (Vector a) #

ofoldl1Ex' :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Element (Vector a) #

headEx :: Vector a -> Element (Vector a) #

lastEx :: Vector a -> Element (Vector a) #

unsafeHead :: Vector a -> Element (Vector a) #

unsafeLast :: Vector a -> Element (Vector a) #

maximumByEx :: (Element (Vector a) -> Element (Vector a) -> Ordering) -> Vector a -> Element (Vector a) #

minimumByEx :: (Element (Vector a) -> Element (Vector a) -> Ordering) -> Vector a -> Element (Vector a) #

oelem :: Element (Vector a) -> Vector a -> Bool #

onotElem :: Element (Vector a) -> Vector a -> Bool #

Storable a => MonoFoldable (Vector a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m #

ofoldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b #

ofoldl' :: (a0 -> Element (Vector a) -> a0) -> a0 -> Vector a -> a0 #

otoList :: Vector a -> [Element (Vector a)] #

oall :: (Element (Vector a) -> Bool) -> Vector a -> Bool #

oany :: (Element (Vector a) -> Bool) -> Vector a -> Bool #

onull :: Vector a -> Bool #

olength :: Vector a -> Int #

olength64 :: Vector a -> Int64 #

ocompareLength :: Integral i => Vector a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Vector a) -> f b) -> Vector a -> f () #

ofor_ :: Applicative f => Vector a -> (Element (Vector a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Vector a) -> m ()) -> Vector a -> m () #

oforM_ :: Applicative m => Vector a -> (Element (Vector a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Vector a) -> m a0) -> a0 -> Vector a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Vector a) -> m) -> Vector a -> m #

ofoldr1Ex :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Element (Vector a) #

ofoldl1Ex' :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Element (Vector a) #

headEx :: Vector a -> Element (Vector a) #

lastEx :: Vector a -> Element (Vector a) #

unsafeHead :: Vector a -> Element (Vector a) #

unsafeLast :: Vector a -> Element (Vector a) #

maximumByEx :: (Element (Vector a) -> Element (Vector a) -> Ordering) -> Vector a -> Element (Vector a) #

minimumByEx :: (Element (Vector a) -> Element (Vector a) -> Ordering) -> Vector a -> Element (Vector a) #

oelem :: Element (Vector a) -> Vector a -> Bool #

onotElem :: Element (Vector a) -> Vector a -> Bool #

Unbox a => MonoFoldable (Vector a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m #

ofoldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b #

ofoldl' :: (a0 -> Element (Vector a) -> a0) -> a0 -> Vector a -> a0 #

otoList :: Vector a -> [Element (Vector a)] #

oall :: (Element (Vector a) -> Bool) -> Vector a -> Bool #

oany :: (Element (Vector a) -> Bool) -> Vector a -> Bool #

onull :: Vector a -> Bool #

olength :: Vector a -> Int #

olength64 :: Vector a -> Int64 #

ocompareLength :: Integral i => Vector a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Vector a) -> f b) -> Vector a -> f () #

ofor_ :: Applicative f => Vector a -> (Element (Vector a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Vector a) -> m ()) -> Vector a -> m () #

oforM_ :: Applicative m => Vector a -> (Element (Vector a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Vector a) -> m a0) -> a0 -> Vector a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Vector a) -> m) -> Vector a -> m #

ofoldr1Ex :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Element (Vector a) #

ofoldl1Ex' :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Element (Vector a) #

headEx :: Vector a -> Element (Vector a) #

lastEx :: Vector a -> Element (Vector a) #

unsafeHead :: Vector a -> Element (Vector a) #

unsafeLast :: Vector a -> Element (Vector a) #

maximumByEx :: (Element (Vector a) -> Element (Vector a) -> Ordering) -> Vector a -> Element (Vector a) #

minimumByEx :: (Element (Vector a) -> Element (Vector a) -> Ordering) -> Vector a -> Element (Vector a) #

oelem :: Element (Vector a) -> Vector a -> Bool #

onotElem :: Element (Vector a) -> Vector a -> Bool #

MonoFoldable (Maybe a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m #

ofoldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b #

ofoldl' :: (a0 -> Element (Maybe a) -> a0) -> a0 -> Maybe a -> a0 #

otoList :: Maybe a -> [Element (Maybe a)] #

oall :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool #

oany :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool #

onull :: Maybe a -> Bool #

olength :: Maybe a -> Int #

olength64 :: Maybe a -> Int64 #

ocompareLength :: Integral i => Maybe a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Maybe a) -> f b) -> Maybe a -> f () #

ofor_ :: Applicative f => Maybe a -> (Element (Maybe a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Maybe a) -> m ()) -> Maybe a -> m () #

oforM_ :: Applicative m => Maybe a -> (Element (Maybe a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Maybe a) -> m a0) -> a0 -> Maybe a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Maybe a) -> m) -> Maybe a -> m #

ofoldr1Ex :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a) #

ofoldl1Ex' :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Element (Maybe a) #

headEx :: Maybe a -> Element (Maybe a) #

lastEx :: Maybe a -> Element (Maybe a) #

unsafeHead :: Maybe a -> Element (Maybe a) #

unsafeLast :: Maybe a -> Element (Maybe a) #

maximumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a) #

minimumByEx :: (Element (Maybe a) -> Element (Maybe a) -> Ordering) -> Maybe a -> Element (Maybe a) #

oelem :: Element (Maybe a) -> Maybe a -> Bool #

onotElem :: Element (Maybe a) -> Maybe a -> Bool #

MonoFoldable [a] # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element [a] -> m) -> [a] -> m #

ofoldr :: (Element [a] -> b -> b) -> b -> [a] -> b #

ofoldl' :: (a0 -> Element [a] -> a0) -> a0 -> [a] -> a0 #

otoList :: [a] -> [Element [a]] #

oall :: (Element [a] -> Bool) -> [a] -> Bool #

oany :: (Element [a] -> Bool) -> [a] -> Bool #

onull :: [a] -> Bool #

olength :: [a] -> Int #

olength64 :: [a] -> Int64 #

ocompareLength :: Integral i => [a] -> i -> Ordering #

otraverse_ :: Applicative f => (Element [a] -> f b) -> [a] -> f () #

ofor_ :: Applicative f => [a] -> (Element [a] -> f b) -> f () #

omapM_ :: Applicative m => (Element [a] -> m ()) -> [a] -> m () #

oforM_ :: Applicative m => [a] -> (Element [a] -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element [a] -> m a0) -> a0 -> [a] -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element [a] -> m) -> [a] -> m #

ofoldr1Ex :: (Element [a] -> Element [a] -> Element [a]) -> [a] -> Element [a] #

ofoldl1Ex' :: (Element [a] -> Element [a] -> Element [a]) -> [a] -> Element [a] #

headEx :: [a] -> Element [a] #

lastEx :: [a] -> Element [a] #

unsafeHead :: [a] -> Element [a] #

unsafeLast :: [a] -> Element [a] #

maximumByEx :: (Element [a] -> Element [a] -> Ordering) -> [a] -> Element [a] #

minimumByEx :: (Element [a] -> Element [a] -> Ordering) -> [a] -> Element [a] #

oelem :: Element [a] -> [a] -> Bool #

onotElem :: Element [a] -> [a] -> Bool #

MonoFoldable (Either a b) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Either a b) -> m) -> Either a b -> m #

ofoldr :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0 #

ofoldl' :: (a0 -> Element (Either a b) -> a0) -> a0 -> Either a b -> a0 #

otoList :: Either a b -> [Element (Either a b)] #

oall :: (Element (Either a b) -> Bool) -> Either a b -> Bool #

oany :: (Element (Either a b) -> Bool) -> Either a b -> Bool #

onull :: Either a b -> Bool #

olength :: Either a b -> Int #

olength64 :: Either a b -> Int64 #

ocompareLength :: Integral i => Either a b -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Either a b) -> f b0) -> Either a b -> f () #

ofor_ :: Applicative f => Either a b -> (Element (Either a b) -> f b0) -> f () #

omapM_ :: Applicative m => (Element (Either a b) -> m ()) -> Either a b -> m () #

oforM_ :: Applicative m => Either a b -> (Element (Either a b) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Either a b) -> m a0) -> a0 -> Either a b -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Either a b) -> m) -> Either a b -> m #

ofoldr1Ex :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Element (Either a b) #

ofoldl1Ex' :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Element (Either a b) #

headEx :: Either a b -> Element (Either a b) #

lastEx :: Either a b -> Element (Either a b) #

unsafeHead :: Either a b -> Element (Either a b) #

unsafeLast :: Either a b -> Element (Either a b) #

maximumByEx :: (Element (Either a b) -> Element (Either a b) -> Ordering) -> Either a b -> Element (Either a b) #

minimumByEx :: (Element (Either a b) -> Element (Either a b) -> Ordering) -> Either a b -> Element (Either a b) #

oelem :: Element (Either a b) -> Either a b -> Bool #

onotElem :: Element (Either a b) -> Either a b -> Bool #

MonoFoldable (Proxy a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Proxy a) -> m) -> Proxy a -> m #

ofoldr :: (Element (Proxy a) -> b -> b) -> b -> Proxy a -> b #

ofoldl' :: (a0 -> Element (Proxy a) -> a0) -> a0 -> Proxy a -> a0 #

otoList :: Proxy a -> [Element (Proxy a)] #

oall :: (Element (Proxy a) -> Bool) -> Proxy a -> Bool #

oany :: (Element (Proxy a) -> Bool) -> Proxy a -> Bool #

onull :: Proxy a -> Bool #

olength :: Proxy a -> Int #

olength64 :: Proxy a -> Int64 #

ocompareLength :: Integral i => Proxy a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Proxy a) -> f b) -> Proxy a -> f () #

ofor_ :: Applicative f => Proxy a -> (Element (Proxy a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Proxy a) -> m ()) -> Proxy a -> m () #

oforM_ :: Applicative m => Proxy a -> (Element (Proxy a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Proxy a) -> m a0) -> a0 -> Proxy a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Proxy a) -> m) -> Proxy a -> m #

ofoldr1Ex :: (Element (Proxy a) -> Element (Proxy a) -> Element (Proxy a)) -> Proxy a -> Element (Proxy a) #

ofoldl1Ex' :: (Element (Proxy a) -> Element (Proxy a) -> Element (Proxy a)) -> Proxy a -> Element (Proxy a) #

headEx :: Proxy a -> Element (Proxy a) #

lastEx :: Proxy a -> Element (Proxy a) #

unsafeHead :: Proxy a -> Element (Proxy a) #

unsafeLast :: Proxy a -> Element (Proxy a) #

maximumByEx :: (Element (Proxy a) -> Element (Proxy a) -> Ordering) -> Proxy a -> Element (Proxy a) #

minimumByEx :: (Element (Proxy a) -> Element (Proxy a) -> Ordering) -> Proxy a -> Element (Proxy a) #

oelem :: Element (Proxy a) -> Proxy a -> Bool #

onotElem :: Element (Proxy a) -> Proxy a -> Bool #

MonoFoldable (U1 a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (U1 a) -> m) -> U1 a -> m #

ofoldr :: (Element (U1 a) -> b -> b) -> b -> U1 a -> b #

ofoldl' :: (a0 -> Element (U1 a) -> a0) -> a0 -> U1 a -> a0 #

otoList :: U1 a -> [Element (U1 a)] #

oall :: (Element (U1 a) -> Bool) -> U1 a -> Bool #

oany :: (Element (U1 a) -> Bool) -> U1 a -> Bool #

onull :: U1 a -> Bool #

olength :: U1 a -> Int #

olength64 :: U1 a -> Int64 #

ocompareLength :: Integral i => U1 a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (U1 a) -> f b) -> U1 a -> f () #

ofor_ :: Applicative f => U1 a -> (Element (U1 a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (U1 a) -> m ()) -> U1 a -> m () #

oforM_ :: Applicative m => U1 a -> (Element (U1 a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (U1 a) -> m a0) -> a0 -> U1 a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (U1 a) -> m) -> U1 a -> m #

ofoldr1Ex :: (Element (U1 a) -> Element (U1 a) -> Element (U1 a)) -> U1 a -> Element (U1 a) #

ofoldl1Ex' :: (Element (U1 a) -> Element (U1 a) -> Element (U1 a)) -> U1 a -> Element (U1 a) #

headEx :: U1 a -> Element (U1 a) #

lastEx :: U1 a -> Element (U1 a) #

unsafeHead :: U1 a -> Element (U1 a) #

unsafeLast :: U1 a -> Element (U1 a) #

maximumByEx :: (Element (U1 a) -> Element (U1 a) -> Ordering) -> U1 a -> Element (U1 a) #

minimumByEx :: (Element (U1 a) -> Element (U1 a) -> Ordering) -> U1 a -> Element (U1 a) #

oelem :: Element (U1 a) -> U1 a -> Bool #

onotElem :: Element (U1 a) -> U1 a -> Bool #

MonoFoldable (V1 a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (V1 a) -> m) -> V1 a -> m #

ofoldr :: (Element (V1 a) -> b -> b) -> b -> V1 a -> b #

ofoldl' :: (a0 -> Element (V1 a) -> a0) -> a0 -> V1 a -> a0 #

otoList :: V1 a -> [Element (V1 a)] #

oall :: (Element (V1 a) -> Bool) -> V1 a -> Bool #

oany :: (Element (V1 a) -> Bool) -> V1 a -> Bool #

onull :: V1 a -> Bool #

olength :: V1 a -> Int #

olength64 :: V1 a -> Int64 #

ocompareLength :: Integral i => V1 a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (V1 a) -> f b) -> V1 a -> f () #

ofor_ :: Applicative f => V1 a -> (Element (V1 a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (V1 a) -> m ()) -> V1 a -> m () #

oforM_ :: Applicative m => V1 a -> (Element (V1 a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (V1 a) -> m a0) -> a0 -> V1 a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (V1 a) -> m) -> V1 a -> m #

ofoldr1Ex :: (Element (V1 a) -> Element (V1 a) -> Element (V1 a)) -> V1 a -> Element (V1 a) #

ofoldl1Ex' :: (Element (V1 a) -> Element (V1 a) -> Element (V1 a)) -> V1 a -> Element (V1 a) #

headEx :: V1 a -> Element (V1 a) #

lastEx :: V1 a -> Element (V1 a) #

unsafeHead :: V1 a -> Element (V1 a) #

unsafeLast :: V1 a -> Element (V1 a) #

maximumByEx :: (Element (V1 a) -> Element (V1 a) -> Ordering) -> V1 a -> Element (V1 a) #

minimumByEx :: (Element (V1 a) -> Element (V1 a) -> Ordering) -> V1 a -> Element (V1 a) #

oelem :: Element (V1 a) -> V1 a -> Bool #

onotElem :: Element (V1 a) -> V1 a -> Bool #

MonoFoldable (Map k v) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Map k v) -> m) -> Map k v -> m #

ofoldr :: (Element (Map k v) -> b -> b) -> b -> Map k v -> b #

ofoldl' :: (a -> Element (Map k v) -> a) -> a -> Map k v -> a #

otoList :: Map k v -> [Element (Map k v)] #

oall :: (Element (Map k v) -> Bool) -> Map k v -> Bool #

oany :: (Element (Map k v) -> Bool) -> Map k v -> Bool #

onull :: Map k v -> Bool #

olength :: Map k v -> Int #

olength64 :: Map k v -> Int64 #

ocompareLength :: Integral i => Map k v -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Map k v) -> f b) -> Map k v -> f () #

ofor_ :: Applicative f => Map k v -> (Element (Map k v) -> f b) -> f () #

omapM_ :: Applicative m => (Element (Map k v) -> m ()) -> Map k v -> m () #

oforM_ :: Applicative m => Map k v -> (Element (Map k v) -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element (Map k v) -> m a) -> a -> Map k v -> m a #

ofoldMap1Ex :: Semigroup m => (Element (Map k v) -> m) -> Map k v -> m #

ofoldr1Ex :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Element (Map k v) #

ofoldl1Ex' :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Element (Map k v) #

headEx :: Map k v -> Element (Map k v) #

lastEx :: Map k v -> Element (Map k v) #

unsafeHead :: Map k v -> Element (Map k v) #

unsafeLast :: Map k v -> Element (Map k v) #

maximumByEx :: (Element (Map k v) -> Element (Map k v) -> Ordering) -> Map k v -> Element (Map k v) #

minimumByEx :: (Element (Map k v) -> Element (Map k v) -> Ordering) -> Map k v -> Element (Map k v) #

oelem :: Element (Map k v) -> Map k v -> Bool #

onotElem :: Element (Map k v) -> Map k v -> Bool #

MonoFoldable mono => MonoFoldable (WrappedMono mono a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (WrappedMono mono a) -> m) -> WrappedMono mono a -> m #

ofoldr :: (Element (WrappedMono mono a) -> b -> b) -> b -> WrappedMono mono a -> b #

ofoldl' :: (a0 -> Element (WrappedMono mono a) -> a0) -> a0 -> WrappedMono mono a -> a0 #

otoList :: WrappedMono mono a -> [Element (WrappedMono mono a)] #

oall :: (Element (WrappedMono mono a) -> Bool) -> WrappedMono mono a -> Bool #

oany :: (Element (WrappedMono mono a) -> Bool) -> WrappedMono mono a -> Bool #

onull :: WrappedMono mono a -> Bool #

olength :: WrappedMono mono a -> Int #

olength64 :: WrappedMono mono a -> Int64 #

ocompareLength :: Integral i => WrappedMono mono a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (WrappedMono mono a) -> f b) -> WrappedMono mono a -> f () #

ofor_ :: Applicative f => WrappedMono mono a -> (Element (WrappedMono mono a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (WrappedMono mono a) -> m ()) -> WrappedMono mono a -> m () #

oforM_ :: Applicative m => WrappedMono mono a -> (Element (WrappedMono mono a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (WrappedMono mono a) -> m a0) -> a0 -> WrappedMono mono a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (WrappedMono mono a) -> m) -> WrappedMono mono a -> m #

ofoldr1Ex :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a) -> Element (WrappedMono mono a)) -> WrappedMono mono a -> Element (WrappedMono mono a) #

ofoldl1Ex' :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a) -> Element (WrappedMono mono a)) -> WrappedMono mono a -> Element (WrappedMono mono a) #

headEx :: WrappedMono mono a -> Element (WrappedMono mono a) #

lastEx :: WrappedMono mono a -> Element (WrappedMono mono a) #

unsafeHead :: WrappedMono mono a -> Element (WrappedMono mono a) #

unsafeLast :: WrappedMono mono a -> Element (WrappedMono mono a) #

maximumByEx :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a) -> Ordering) -> WrappedMono mono a -> Element (WrappedMono mono a) #

minimumByEx :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a) -> Ordering) -> WrappedMono mono a -> Element (WrappedMono mono a) #

oelem :: Element (WrappedMono mono a) -> WrappedMono mono a -> Bool #

onotElem :: Element (WrappedMono mono a) -> WrappedMono mono a -> Bool #

Foldable f => MonoFoldable (WrappedPoly f a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (WrappedPoly f a) -> m) -> WrappedPoly f a -> m #

ofoldr :: (Element (WrappedPoly f a) -> b -> b) -> b -> WrappedPoly f a -> b #

ofoldl' :: (a0 -> Element (WrappedPoly f a) -> a0) -> a0 -> WrappedPoly f a -> a0 #

otoList :: WrappedPoly f a -> [Element (WrappedPoly f a)] #

oall :: (Element (WrappedPoly f a) -> Bool) -> WrappedPoly f a -> Bool #

oany :: (Element (WrappedPoly f a) -> Bool) -> WrappedPoly f a -> Bool #

onull :: WrappedPoly f a -> Bool #

olength :: WrappedPoly f a -> Int #

olength64 :: WrappedPoly f a -> Int64 #

ocompareLength :: Integral i => WrappedPoly f a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element (WrappedPoly f a) -> f0 b) -> WrappedPoly f a -> f0 () #

ofor_ :: Applicative f0 => WrappedPoly f a -> (Element (WrappedPoly f a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (WrappedPoly f a) -> m ()) -> WrappedPoly f a -> m () #

oforM_ :: Applicative m => WrappedPoly f a -> (Element (WrappedPoly f a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (WrappedPoly f a) -> m a0) -> a0 -> WrappedPoly f a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (WrappedPoly f a) -> m) -> WrappedPoly f a -> m #

ofoldr1Ex :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a) -> Element (WrappedPoly f a)) -> WrappedPoly f a -> Element (WrappedPoly f a) #

ofoldl1Ex' :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a) -> Element (WrappedPoly f a)) -> WrappedPoly f a -> Element (WrappedPoly f a) #

headEx :: WrappedPoly f a -> Element (WrappedPoly f a) #

lastEx :: WrappedPoly f a -> Element (WrappedPoly f a) #

unsafeHead :: WrappedPoly f a -> Element (WrappedPoly f a) #

unsafeLast :: WrappedPoly f a -> Element (WrappedPoly f a) #

maximumByEx :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a) -> Ordering) -> WrappedPoly f a -> Element (WrappedPoly f a) #

minimumByEx :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a) -> Ordering) -> WrappedPoly f a -> Element (WrappedPoly f a) #

oelem :: Element (WrappedPoly f a) -> WrappedPoly f a -> Bool #

onotElem :: Element (WrappedPoly f a) -> WrappedPoly f a -> Bool #

Foldable f => MonoFoldable (MaybeT f a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (MaybeT f a) -> m) -> MaybeT f a -> m #

ofoldr :: (Element (MaybeT f a) -> b -> b) -> b -> MaybeT f a -> b #

ofoldl' :: (a0 -> Element (MaybeT f a) -> a0) -> a0 -> MaybeT f a -> a0 #

otoList :: MaybeT f a -> [Element (MaybeT f a)] #

oall :: (Element (MaybeT f a) -> Bool) -> MaybeT f a -> Bool #

oany :: (Element (MaybeT f a) -> Bool) -> MaybeT f a -> Bool #

onull :: MaybeT f a -> Bool #

olength :: MaybeT f a -> Int #

olength64 :: MaybeT f a -> Int64 #

ocompareLength :: Integral i => MaybeT f a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element (MaybeT f a) -> f0 b) -> MaybeT f a -> f0 () #

ofor_ :: Applicative f0 => MaybeT f a -> (Element (MaybeT f a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (MaybeT f a) -> m ()) -> MaybeT f a -> m () #

oforM_ :: Applicative m => MaybeT f a -> (Element (MaybeT f a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (MaybeT f a) -> m a0) -> a0 -> MaybeT f a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (MaybeT f a) -> m) -> MaybeT f a -> m #

ofoldr1Ex :: (Element (MaybeT f a) -> Element (MaybeT f a) -> Element (MaybeT f a)) -> MaybeT f a -> Element (MaybeT f a) #

ofoldl1Ex' :: (Element (MaybeT f a) -> Element (MaybeT f a) -> Element (MaybeT f a)) -> MaybeT f a -> Element (MaybeT f a) #

headEx :: MaybeT f a -> Element (MaybeT f a) #

lastEx :: MaybeT f a -> Element (MaybeT f a) #

unsafeHead :: MaybeT f a -> Element (MaybeT f a) #

unsafeLast :: MaybeT f a -> Element (MaybeT f a) #

maximumByEx :: (Element (MaybeT f a) -> Element (MaybeT f a) -> Ordering) -> MaybeT f a -> Element (MaybeT f a) #

minimumByEx :: (Element (MaybeT f a) -> Element (MaybeT f a) -> Ordering) -> MaybeT f a -> Element (MaybeT f a) #

oelem :: Element (MaybeT f a) -> MaybeT f a -> Bool #

onotElem :: Element (MaybeT f a) -> MaybeT f a -> Bool #

MonoFoldable (HashMap k v) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (HashMap k v) -> m) -> HashMap k v -> m #

ofoldr :: (Element (HashMap k v) -> b -> b) -> b -> HashMap k v -> b #

ofoldl' :: (a -> Element (HashMap k v) -> a) -> a -> HashMap k v -> a #

otoList :: HashMap k v -> [Element (HashMap k v)] #

oall :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Bool #

oany :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Bool #

onull :: HashMap k v -> Bool #

olength :: HashMap k v -> Int #

olength64 :: HashMap k v -> Int64 #

ocompareLength :: Integral i => HashMap k v -> i -> Ordering #

otraverse_ :: Applicative f => (Element (HashMap k v) -> f b) -> HashMap k v -> f () #

ofor_ :: Applicative f => HashMap k v -> (Element (HashMap k v) -> f b) -> f () #

omapM_ :: Applicative m => (Element (HashMap k v) -> m ()) -> HashMap k v -> m () #

oforM_ :: Applicative m => HashMap k v -> (Element (HashMap k v) -> m ()) -> m () #

ofoldlM :: Monad m => (a -> Element (HashMap k v) -> m a) -> a -> HashMap k v -> m a #

ofoldMap1Ex :: Semigroup m => (Element (HashMap k v) -> m) -> HashMap k v -> m #

ofoldr1Ex :: (Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> Element (HashMap k v) #

ofoldl1Ex' :: (Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> Element (HashMap k v) #

headEx :: HashMap k v -> Element (HashMap k v) #

lastEx :: HashMap k v -> Element (HashMap k v) #

unsafeHead :: HashMap k v -> Element (HashMap k v) #

unsafeLast :: HashMap k v -> Element (HashMap k v) #

maximumByEx :: (Element (HashMap k v) -> Element (HashMap k v) -> Ordering) -> HashMap k v -> Element (HashMap k v) #

minimumByEx :: (Element (HashMap k v) -> Element (HashMap k v) -> Ordering) -> HashMap k v -> Element (HashMap k v) #

oelem :: Element (HashMap k v) -> HashMap k v -> Bool #

onotElem :: Element (HashMap k v) -> HashMap k v -> Bool #

MonoFoldable (a, b) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (a, b) -> m) -> (a, b) -> m #

ofoldr :: (Element (a, b) -> b0 -> b0) -> b0 -> (a, b) -> b0 #

ofoldl' :: (a0 -> Element (a, b) -> a0) -> a0 -> (a, b) -> a0 #

otoList :: (a, b) -> [Element (a, b)] #

oall :: (Element (a, b) -> Bool) -> (a, b) -> Bool #

oany :: (Element (a, b) -> Bool) -> (a, b) -> Bool #

onull :: (a, b) -> Bool #

olength :: (a, b) -> Int #

olength64 :: (a, b) -> Int64 #

ocompareLength :: Integral i => (a, b) -> i -> Ordering #

otraverse_ :: Applicative f => (Element (a, b) -> f b0) -> (a, b) -> f () #

ofor_ :: Applicative f => (a, b) -> (Element (a, b) -> f b0) -> f () #

omapM_ :: Applicative m => (Element (a, b) -> m ()) -> (a, b) -> m () #

oforM_ :: Applicative m => (a, b) -> (Element (a, b) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (a, b) -> m a0) -> a0 -> (a, b) -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (a, b) -> m) -> (a, b) -> m #

ofoldr1Ex :: (Element (a, b) -> Element (a, b) -> Element (a, b)) -> (a, b) -> Element (a, b) #

ofoldl1Ex' :: (Element (a, b) -> Element (a, b) -> Element (a, b)) -> (a, b) -> Element (a, b) #

headEx :: (a, b) -> Element (a, b) #

lastEx :: (a, b) -> Element (a, b) #

unsafeHead :: (a, b) -> Element (a, b) #

unsafeLast :: (a, b) -> Element (a, b) #

maximumByEx :: (Element (a, b) -> Element (a, b) -> Ordering) -> (a, b) -> Element (a, b) #

minimumByEx :: (Element (a, b) -> Element (a, b) -> Ordering) -> (a, b) -> Element (a, b) #

oelem :: Element (a, b) -> (a, b) -> Bool #

onotElem :: Element (a, b) -> (a, b) -> Bool #

MonoFoldable (Const m a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m0 => (Element (Const m a) -> m0) -> Const m a -> m0 #

ofoldr :: (Element (Const m a) -> b -> b) -> b -> Const m a -> b #

ofoldl' :: (a0 -> Element (Const m a) -> a0) -> a0 -> Const m a -> a0 #

otoList :: Const m a -> [Element (Const m a)] #

oall :: (Element (Const m a) -> Bool) -> Const m a -> Bool #

oany :: (Element (Const m a) -> Bool) -> Const m a -> Bool #

onull :: Const m a -> Bool #

olength :: Const m a -> Int #

olength64 :: Const m a -> Int64 #

ocompareLength :: Integral i => Const m a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (Const m a) -> f b) -> Const m a -> f () #

ofor_ :: Applicative f => Const m a -> (Element (Const m a) -> f b) -> f () #

omapM_ :: Applicative m0 => (Element (Const m a) -> m0 ()) -> Const m a -> m0 () #

oforM_ :: Applicative m0 => Const m a -> (Element (Const m a) -> m0 ()) -> m0 () #

ofoldlM :: Monad m0 => (a0 -> Element (Const m a) -> m0 a0) -> a0 -> Const m a -> m0 a0 #

ofoldMap1Ex :: Semigroup m0 => (Element (Const m a) -> m0) -> Const m a -> m0 #

ofoldr1Ex :: (Element (Const m a) -> Element (Const m a) -> Element (Const m a)) -> Const m a -> Element (Const m a) #

ofoldl1Ex' :: (Element (Const m a) -> Element (Const m a) -> Element (Const m a)) -> Const m a -> Element (Const m a) #

headEx :: Const m a -> Element (Const m a) #

lastEx :: Const m a -> Element (Const m a) #

unsafeHead :: Const m a -> Element (Const m a) #

unsafeLast :: Const m a -> Element (Const m a) #

maximumByEx :: (Element (Const m a) -> Element (Const m a) -> Ordering) -> Const m a -> Element (Const m a) #

minimumByEx :: (Element (Const m a) -> Element (Const m a) -> Ordering) -> Const m a -> Element (Const m a) #

oelem :: Element (Const m a) -> Const m a -> Bool #

onotElem :: Element (Const m a) -> Const m a -> Bool #

Foldable f => MonoFoldable (Rec1 f a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Rec1 f a) -> m) -> Rec1 f a -> m #

ofoldr :: (Element (Rec1 f a) -> b -> b) -> b -> Rec1 f a -> b #

ofoldl' :: (a0 -> Element (Rec1 f a) -> a0) -> a0 -> Rec1 f a -> a0 #

otoList :: Rec1 f a -> [Element (Rec1 f a)] #

oall :: (Element (Rec1 f a) -> Bool) -> Rec1 f a -> Bool #

oany :: (Element (Rec1 f a) -> Bool) -> Rec1 f a -> Bool #

onull :: Rec1 f a -> Bool #

olength :: Rec1 f a -> Int #

olength64 :: Rec1 f a -> Int64 #

ocompareLength :: Integral i => Rec1 f a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element (Rec1 f a) -> f0 b) -> Rec1 f a -> f0 () #

ofor_ :: Applicative f0 => Rec1 f a -> (Element (Rec1 f a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (Rec1 f a) -> m ()) -> Rec1 f a -> m () #

oforM_ :: Applicative m => Rec1 f a -> (Element (Rec1 f a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Rec1 f a) -> m a0) -> a0 -> Rec1 f a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Rec1 f a) -> m) -> Rec1 f a -> m #

ofoldr1Ex :: (Element (Rec1 f a) -> Element (Rec1 f a) -> Element (Rec1 f a)) -> Rec1 f a -> Element (Rec1 f a) #

ofoldl1Ex' :: (Element (Rec1 f a) -> Element (Rec1 f a) -> Element (Rec1 f a)) -> Rec1 f a -> Element (Rec1 f a) #

headEx :: Rec1 f a -> Element (Rec1 f a) #

lastEx :: Rec1 f a -> Element (Rec1 f a) #

unsafeHead :: Rec1 f a -> Element (Rec1 f a) #

unsafeLast :: Rec1 f a -> Element (Rec1 f a) #

maximumByEx :: (Element (Rec1 f a) -> Element (Rec1 f a) -> Ordering) -> Rec1 f a -> Element (Rec1 f a) #

minimumByEx :: (Element (Rec1 f a) -> Element (Rec1 f a) -> Ordering) -> Rec1 f a -> Element (Rec1 f a) #

oelem :: Element (Rec1 f a) -> Rec1 f a -> Bool #

onotElem :: Element (Rec1 f a) -> Rec1 f a -> Bool #

Foldable f => MonoFoldable (IdentityT f a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (IdentityT f a) -> m) -> IdentityT f a -> m #

ofoldr :: (Element (IdentityT f a) -> b -> b) -> b -> IdentityT f a -> b #

ofoldl' :: (a0 -> Element (IdentityT f a) -> a0) -> a0 -> IdentityT f a -> a0 #

otoList :: IdentityT f a -> [Element (IdentityT f a)] #

oall :: (Element (IdentityT f a) -> Bool) -> IdentityT f a -> Bool #

oany :: (Element (IdentityT f a) -> Bool) -> IdentityT f a -> Bool #

onull :: IdentityT f a -> Bool #

olength :: IdentityT f a -> Int #

olength64 :: IdentityT f a -> Int64 #

ocompareLength :: Integral i => IdentityT f a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element (IdentityT f a) -> f0 b) -> IdentityT f a -> f0 () #

ofor_ :: Applicative f0 => IdentityT f a -> (Element (IdentityT f a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (IdentityT f a) -> m ()) -> IdentityT f a -> m () #

oforM_ :: Applicative m => IdentityT f a -> (Element (IdentityT f a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (IdentityT f a) -> m a0) -> a0 -> IdentityT f a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (IdentityT f a) -> m) -> IdentityT f a -> m #

ofoldr1Ex :: (Element (IdentityT f a) -> Element (IdentityT f a) -> Element (IdentityT f a)) -> IdentityT f a -> Element (IdentityT f a) #

ofoldl1Ex' :: (Element (IdentityT f a) -> Element (IdentityT f a) -> Element (IdentityT f a)) -> IdentityT f a -> Element (IdentityT f a) #

headEx :: IdentityT f a -> Element (IdentityT f a) #

lastEx :: IdentityT f a -> Element (IdentityT f a) #

unsafeHead :: IdentityT f a -> Element (IdentityT f a) #

unsafeLast :: IdentityT f a -> Element (IdentityT f a) #

maximumByEx :: (Element (IdentityT f a) -> Element (IdentityT f a) -> Ordering) -> IdentityT f a -> Element (IdentityT f a) #

minimumByEx :: (Element (IdentityT f a) -> Element (IdentityT f a) -> Ordering) -> IdentityT f a -> Element (IdentityT f a) #

oelem :: Element (IdentityT f a) -> IdentityT f a -> Bool #

onotElem :: Element (IdentityT f a) -> IdentityT f a -> Bool #

Foldable f => MonoFoldable (WriterT w f a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (WriterT w f a) -> m) -> WriterT w f a -> m #

ofoldr :: (Element (WriterT w f a) -> b -> b) -> b -> WriterT w f a -> b #

ofoldl' :: (a0 -> Element (WriterT w f a) -> a0) -> a0 -> WriterT w f a -> a0 #

otoList :: WriterT w f a -> [Element (WriterT w f a)] #

oall :: (Element (WriterT w f a) -> Bool) -> WriterT w f a -> Bool #

oany :: (Element (WriterT w f a) -> Bool) -> WriterT w f a -> Bool #

onull :: WriterT w f a -> Bool #

olength :: WriterT w f a -> Int #

olength64 :: WriterT w f a -> Int64 #

ocompareLength :: Integral i => WriterT w f a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element (WriterT w f a) -> f0 b) -> WriterT w f a -> f0 () #

ofor_ :: Applicative f0 => WriterT w f a -> (Element (WriterT w f a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (WriterT w f a) -> m ()) -> WriterT w f a -> m () #

oforM_ :: Applicative m => WriterT w f a -> (Element (WriterT w f a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (WriterT w f a) -> m a0) -> a0 -> WriterT w f a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (WriterT w f a) -> m) -> WriterT w f a -> m #

ofoldr1Ex :: (Element (WriterT w f a) -> Element (WriterT w f a) -> Element (WriterT w f a)) -> WriterT w f a -> Element (WriterT w f a) #

ofoldl1Ex' :: (Element (WriterT w f a) -> Element (WriterT w f a) -> Element (WriterT w f a)) -> WriterT w f a -> Element (WriterT w f a) #

headEx :: WriterT w f a -> Element (WriterT w f a) #

lastEx :: WriterT w f a -> Element (WriterT w f a) #

unsafeHead :: WriterT w f a -> Element (WriterT w f a) #

unsafeLast :: WriterT w f a -> Element (WriterT w f a) #

maximumByEx :: (Element (WriterT w f a) -> Element (WriterT w f a) -> Ordering) -> WriterT w f a -> Element (WriterT w f a) #

minimumByEx :: (Element (WriterT w f a) -> Element (WriterT w f a) -> Ordering) -> WriterT w f a -> Element (WriterT w f a) #

oelem :: Element (WriterT w f a) -> WriterT w f a -> Bool #

onotElem :: Element (WriterT w f a) -> WriterT w f a -> Bool #

Foldable f => MonoFoldable (WriterT w f a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (WriterT w f a) -> m) -> WriterT w f a -> m #

ofoldr :: (Element (WriterT w f a) -> b -> b) -> b -> WriterT w f a -> b #

ofoldl' :: (a0 -> Element (WriterT w f a) -> a0) -> a0 -> WriterT w f a -> a0 #

otoList :: WriterT w f a -> [Element (WriterT w f a)] #

oall :: (Element (WriterT w f a) -> Bool) -> WriterT w f a -> Bool #

oany :: (Element (WriterT w f a) -> Bool) -> WriterT w f a -> Bool #

onull :: WriterT w f a -> Bool #

olength :: WriterT w f a -> Int #

olength64 :: WriterT w f a -> Int64 #

ocompareLength :: Integral i => WriterT w f a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element (WriterT w f a) -> f0 b) -> WriterT w f a -> f0 () #

ofor_ :: Applicative f0 => WriterT w f a -> (Element (WriterT w f a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (WriterT w f a) -> m ()) -> WriterT w f a -> m () #

oforM_ :: Applicative m => WriterT w f a -> (Element (WriterT w f a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (WriterT w f a) -> m a0) -> a0 -> WriterT w f a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (WriterT w f a) -> m) -> WriterT w f a -> m #

ofoldr1Ex :: (Element (WriterT w f a) -> Element (WriterT w f a) -> Element (WriterT w f a)) -> WriterT w f a -> Element (WriterT w f a) #

ofoldl1Ex' :: (Element (WriterT w f a) -> Element (WriterT w f a) -> Element (WriterT w f a)) -> WriterT w f a -> Element (WriterT w f a) #

headEx :: WriterT w f a -> Element (WriterT w f a) #

lastEx :: WriterT w f a -> Element (WriterT w f a) #

unsafeHead :: WriterT w f a -> Element (WriterT w f a) #

unsafeLast :: WriterT w f a -> Element (WriterT w f a) #

maximumByEx :: (Element (WriterT w f a) -> Element (WriterT w f a) -> Ordering) -> WriterT w f a -> Element (WriterT w f a) #

minimumByEx :: (Element (WriterT w f a) -> Element (WriterT w f a) -> Ordering) -> WriterT w f a -> Element (WriterT w f a) #

oelem :: Element (WriterT w f a) -> WriterT w f a -> Bool #

onotElem :: Element (WriterT w f a) -> WriterT w f a -> Bool #

(Foldable f, Foldable g) => MonoFoldable (Product f g a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Product f g a) -> m) -> Product f g a -> m #

ofoldr :: (Element (Product f g a) -> b -> b) -> b -> Product f g a -> b #

ofoldl' :: (a0 -> Element (Product f g a) -> a0) -> a0 -> Product f g a -> a0 #

otoList :: Product f g a -> [Element (Product f g a)] #

oall :: (Element (Product f g a) -> Bool) -> Product f g a -> Bool #

oany :: (Element (Product f g a) -> Bool) -> Product f g a -> Bool #

onull :: Product f g a -> Bool #

olength :: Product f g a -> Int #

olength64 :: Product f g a -> Int64 #

ocompareLength :: Integral i => Product f g a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element (Product f g a) -> f0 b) -> Product f g a -> f0 () #

ofor_ :: Applicative f0 => Product f g a -> (Element (Product f g a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (Product f g a) -> m ()) -> Product f g a -> m () #

oforM_ :: Applicative m => Product f g a -> (Element (Product f g a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Product f g a) -> m a0) -> a0 -> Product f g a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Product f g a) -> m) -> Product f g a -> m #

ofoldr1Ex :: (Element (Product f g a) -> Element (Product f g a) -> Element (Product f g a)) -> Product f g a -> Element (Product f g a) #

ofoldl1Ex' :: (Element (Product f g a) -> Element (Product f g a) -> Element (Product f g a)) -> Product f g a -> Element (Product f g a) #

headEx :: Product f g a -> Element (Product f g a) #

lastEx :: Product f g a -> Element (Product f g a) #

unsafeHead :: Product f g a -> Element (Product f g a) #

unsafeLast :: Product f g a -> Element (Product f g a) #

maximumByEx :: (Element (Product f g a) -> Element (Product f g a) -> Ordering) -> Product f g a -> Element (Product f g a) #

minimumByEx :: (Element (Product f g a) -> Element (Product f g a) -> Ordering) -> Product f g a -> Element (Product f g a) #

oelem :: Element (Product f g a) -> Product f g a -> Bool #

onotElem :: Element (Product f g a) -> Product f g a -> Bool #

(Foldable f, Foldable g) => MonoFoldable ((f :*: g) a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element ((f :*: g) a) -> m) -> (f :*: g) a -> m #

ofoldr :: (Element ((f :*: g) a) -> b -> b) -> b -> (f :*: g) a -> b #

ofoldl' :: (a0 -> Element ((f :*: g) a) -> a0) -> a0 -> (f :*: g) a -> a0 #

otoList :: (f :*: g) a -> [Element ((f :*: g) a)] #

oall :: (Element ((f :*: g) a) -> Bool) -> (f :*: g) a -> Bool #

oany :: (Element ((f :*: g) a) -> Bool) -> (f :*: g) a -> Bool #

onull :: (f :*: g) a -> Bool #

olength :: (f :*: g) a -> Int #

olength64 :: (f :*: g) a -> Int64 #

ocompareLength :: Integral i => (f :*: g) a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element ((f :*: g) a) -> f0 b) -> (f :*: g) a -> f0 () #

ofor_ :: Applicative f0 => (f :*: g) a -> (Element ((f :*: g) a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element ((f :*: g) a) -> m ()) -> (f :*: g) a -> m () #

oforM_ :: Applicative m => (f :*: g) a -> (Element ((f :*: g) a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element ((f :*: g) a) -> m a0) -> a0 -> (f :*: g) a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element ((f :*: g) a) -> m) -> (f :*: g) a -> m #

ofoldr1Ex :: (Element ((f :*: g) a) -> Element ((f :*: g) a) -> Element ((f :*: g) a)) -> (f :*: g) a -> Element ((f :*: g) a) #

ofoldl1Ex' :: (Element ((f :*: g) a) -> Element ((f :*: g) a) -> Element ((f :*: g) a)) -> (f :*: g) a -> Element ((f :*: g) a) #

headEx :: (f :*: g) a -> Element ((f :*: g) a) #

lastEx :: (f :*: g) a -> Element ((f :*: g) a) #

unsafeHead :: (f :*: g) a -> Element ((f :*: g) a) #

unsafeLast :: (f :*: g) a -> Element ((f :*: g) a) #

maximumByEx :: (Element ((f :*: g) a) -> Element ((f :*: g) a) -> Ordering) -> (f :*: g) a -> Element ((f :*: g) a) #

minimumByEx :: (Element ((f :*: g) a) -> Element ((f :*: g) a) -> Ordering) -> (f :*: g) a -> Element ((f :*: g) a) #

oelem :: Element ((f :*: g) a) -> (f :*: g) a -> Bool #

onotElem :: Element ((f :*: g) a) -> (f :*: g) a -> Bool #

(Foldable f, Foldable g) => MonoFoldable ((f :+: g) a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element ((f :+: g) a) -> m) -> (f :+: g) a -> m #

ofoldr :: (Element ((f :+: g) a) -> b -> b) -> b -> (f :+: g) a -> b #

ofoldl' :: (a0 -> Element ((f :+: g) a) -> a0) -> a0 -> (f :+: g) a -> a0 #

otoList :: (f :+: g) a -> [Element ((f :+: g) a)] #

oall :: (Element ((f :+: g) a) -> Bool) -> (f :+: g) a -> Bool #

oany :: (Element ((f :+: g) a) -> Bool) -> (f :+: g) a -> Bool #

onull :: (f :+: g) a -> Bool #

olength :: (f :+: g) a -> Int #

olength64 :: (f :+: g) a -> Int64 #

ocompareLength :: Integral i => (f :+: g) a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element ((f :+: g) a) -> f0 b) -> (f :+: g) a -> f0 () #

ofor_ :: Applicative f0 => (f :+: g) a -> (Element ((f :+: g) a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element ((f :+: g) a) -> m ()) -> (f :+: g) a -> m () #

oforM_ :: Applicative m => (f :+: g) a -> (Element ((f :+: g) a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element ((f :+: g) a) -> m a0) -> a0 -> (f :+: g) a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element ((f :+: g) a) -> m) -> (f :+: g) a -> m #

ofoldr1Ex :: (Element ((f :+: g) a) -> Element ((f :+: g) a) -> Element ((f :+: g) a)) -> (f :+: g) a -> Element ((f :+: g) a) #

ofoldl1Ex' :: (Element ((f :+: g) a) -> Element ((f :+: g) a) -> Element ((f :+: g) a)) -> (f :+: g) a -> Element ((f :+: g) a) #

headEx :: (f :+: g) a -> Element ((f :+: g) a) #

lastEx :: (f :+: g) a -> Element ((f :+: g) a) #

unsafeHead :: (f :+: g) a -> Element ((f :+: g) a) #

unsafeLast :: (f :+: g) a -> Element ((f :+: g) a) #

maximumByEx :: (Element ((f :+: g) a) -> Element ((f :+: g) a) -> Ordering) -> (f :+: g) a -> Element ((f :+: g) a) #

minimumByEx :: (Element ((f :+: g) a) -> Element ((f :+: g) a) -> Ordering) -> (f :+: g) a -> Element ((f :+: g) a) #

oelem :: Element ((f :+: g) a) -> (f :+: g) a -> Bool #

onotElem :: Element ((f :+: g) a) -> (f :+: g) a -> Bool #

MonoFoldable (K1 i c a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (K1 i c a) -> m) -> K1 i c a -> m #

ofoldr :: (Element (K1 i c a) -> b -> b) -> b -> K1 i c a -> b #

ofoldl' :: (a0 -> Element (K1 i c a) -> a0) -> a0 -> K1 i c a -> a0 #

otoList :: K1 i c a -> [Element (K1 i c a)] #

oall :: (Element (K1 i c a) -> Bool) -> K1 i c a -> Bool #

oany :: (Element (K1 i c a) -> Bool) -> K1 i c a -> Bool #

onull :: K1 i c a -> Bool #

olength :: K1 i c a -> Int #

olength64 :: K1 i c a -> Int64 #

ocompareLength :: Integral i0 => K1 i c a -> i0 -> Ordering #

otraverse_ :: Applicative f => (Element (K1 i c a) -> f b) -> K1 i c a -> f () #

ofor_ :: Applicative f => K1 i c a -> (Element (K1 i c a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (K1 i c a) -> m ()) -> K1 i c a -> m () #

oforM_ :: Applicative m => K1 i c a -> (Element (K1 i c a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (K1 i c a) -> m a0) -> a0 -> K1 i c a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (K1 i c a) -> m) -> K1 i c a -> m #

ofoldr1Ex :: (Element (K1 i c a) -> Element (K1 i c a) -> Element (K1 i c a)) -> K1 i c a -> Element (K1 i c a) #

ofoldl1Ex' :: (Element (K1 i c a) -> Element (K1 i c a) -> Element (K1 i c a)) -> K1 i c a -> Element (K1 i c a) #

headEx :: K1 i c a -> Element (K1 i c a) #

lastEx :: K1 i c a -> Element (K1 i c a) #

unsafeHead :: K1 i c a -> Element (K1 i c a) #

unsafeLast :: K1 i c a -> Element (K1 i c a) #

maximumByEx :: (Element (K1 i c a) -> Element (K1 i c a) -> Ordering) -> K1 i c a -> Element (K1 i c a) #

minimumByEx :: (Element (K1 i c a) -> Element (K1 i c a) -> Ordering) -> K1 i c a -> Element (K1 i c a) #

oelem :: Element (K1 i c a) -> K1 i c a -> Bool #

onotElem :: Element (K1 i c a) -> K1 i c a -> Bool #

(Foldable f, Foldable g) => MonoFoldable (Compose f g a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (Compose f g a) -> m) -> Compose f g a -> m #

ofoldr :: (Element (Compose f g a) -> b -> b) -> b -> Compose f g a -> b #

ofoldl' :: (a0 -> Element (Compose f g a) -> a0) -> a0 -> Compose f g a -> a0 #

otoList :: Compose f g a -> [Element (Compose f g a)] #

oall :: (Element (Compose f g a) -> Bool) -> Compose f g a -> Bool #

oany :: (Element (Compose f g a) -> Bool) -> Compose f g a -> Bool #

onull :: Compose f g a -> Bool #

olength :: Compose f g a -> Int #

olength64 :: Compose f g a -> Int64 #

ocompareLength :: Integral i => Compose f g a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element (Compose f g a) -> f0 b) -> Compose f g a -> f0 () #

ofor_ :: Applicative f0 => Compose f g a -> (Element (Compose f g a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (Compose f g a) -> m ()) -> Compose f g a -> m () #

oforM_ :: Applicative m => Compose f g a -> (Element (Compose f g a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (Compose f g a) -> m a0) -> a0 -> Compose f g a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (Compose f g a) -> m) -> Compose f g a -> m #

ofoldr1Ex :: (Element (Compose f g a) -> Element (Compose f g a) -> Element (Compose f g a)) -> Compose f g a -> Element (Compose f g a) #

ofoldl1Ex' :: (Element (Compose f g a) -> Element (Compose f g a) -> Element (Compose f g a)) -> Compose f g a -> Element (Compose f g a) #

headEx :: Compose f g a -> Element (Compose f g a) #

lastEx :: Compose f g a -> Element (Compose f g a) #

unsafeHead :: Compose f g a -> Element (Compose f g a) #

unsafeLast :: Compose f g a -> Element (Compose f g a) #

maximumByEx :: (Element (Compose f g a) -> Element (Compose f g a) -> Ordering) -> Compose f g a -> Element (Compose f g a) #

minimumByEx :: (Element (Compose f g a) -> Element (Compose f g a) -> Ordering) -> Compose f g a -> Element (Compose f g a) #

oelem :: Element (Compose f g a) -> Compose f g a -> Bool #

onotElem :: Element (Compose f g a) -> Compose f g a -> Bool #

(Foldable f, Foldable g) => MonoFoldable ((f :.: g) a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element ((f :.: g) a) -> m) -> (f :.: g) a -> m #

ofoldr :: (Element ((f :.: g) a) -> b -> b) -> b -> (f :.: g) a -> b #

ofoldl' :: (a0 -> Element ((f :.: g) a) -> a0) -> a0 -> (f :.: g) a -> a0 #

otoList :: (f :.: g) a -> [Element ((f :.: g) a)] #

oall :: (Element ((f :.: g) a) -> Bool) -> (f :.: g) a -> Bool #

oany :: (Element ((f :.: g) a) -> Bool) -> (f :.: g) a -> Bool #

onull :: (f :.: g) a -> Bool #

olength :: (f :.: g) a -> Int #

olength64 :: (f :.: g) a -> Int64 #

ocompareLength :: Integral i => (f :.: g) a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element ((f :.: g) a) -> f0 b) -> (f :.: g) a -> f0 () #

ofor_ :: Applicative f0 => (f :.: g) a -> (Element ((f :.: g) a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element ((f :.: g) a) -> m ()) -> (f :.: g) a -> m () #

oforM_ :: Applicative m => (f :.: g) a -> (Element ((f :.: g) a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element ((f :.: g) a) -> m a0) -> a0 -> (f :.: g) a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element ((f :.: g) a) -> m) -> (f :.: g) a -> m #

ofoldr1Ex :: (Element ((f :.: g) a) -> Element ((f :.: g) a) -> Element ((f :.: g) a)) -> (f :.: g) a -> Element ((f :.: g) a) #

ofoldl1Ex' :: (Element ((f :.: g) a) -> Element ((f :.: g) a) -> Element ((f :.: g) a)) -> (f :.: g) a -> Element ((f :.: g) a) #

headEx :: (f :.: g) a -> Element ((f :.: g) a) #

lastEx :: (f :.: g) a -> Element ((f :.: g) a) #

unsafeHead :: (f :.: g) a -> Element ((f :.: g) a) #

unsafeLast :: (f :.: g) a -> Element ((f :.: g) a) #

maximumByEx :: (Element ((f :.: g) a) -> Element ((f :.: g) a) -> Ordering) -> (f :.: g) a -> Element ((f :.: g) a) #

minimumByEx :: (Element ((f :.: g) a) -> Element ((f :.: g) a) -> Ordering) -> (f :.: g) a -> Element ((f :.: g) a) #

oelem :: Element ((f :.: g) a) -> (f :.: g) a -> Bool #

onotElem :: Element ((f :.: g) a) -> (f :.: g) a -> Bool #

Foldable f => MonoFoldable (M1 i c f a) # | Since: 1.0.11.0

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (M1 i c f a) -> m) -> M1 i c f a -> m #

ofoldr :: (Element (M1 i c f a) -> b -> b) -> b -> M1 i c f a -> b #

ofoldl' :: (a0 -> Element (M1 i c f a) -> a0) -> a0 -> M1 i c f a -> a0 #

otoList :: M1 i c f a -> [Element (M1 i c f a)] #

oall :: (Element (M1 i c f a) -> Bool) -> M1 i c f a -> Bool #

oany :: (Element (M1 i c f a) -> Bool) -> M1 i c f a -> Bool #

onull :: M1 i c f a -> Bool #

olength :: M1 i c f a -> Int #

olength64 :: M1 i c f a -> Int64 #

ocompareLength :: Integral i0 => M1 i c f a -> i0 -> Ordering #

otraverse_ :: Applicative f0 => (Element (M1 i c f a) -> f0 b) -> M1 i c f a -> f0 () #

ofor_ :: Applicative f0 => M1 i c f a -> (Element (M1 i c f a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (M1 i c f a) -> m ()) -> M1 i c f a -> m () #

oforM_ :: Applicative m => M1 i c f a -> (Element (M1 i c f a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (M1 i c f a) -> m a0) -> a0 -> M1 i c f a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (M1 i c f a) -> m) -> M1 i c f a -> m #

ofoldr1Ex :: (Element (M1 i c f a) -> Element (M1 i c f a) -> Element (M1 i c f a)) -> M1 i c f a -> Element (M1 i c f a) #

ofoldl1Ex' :: (Element (M1 i c f a) -> Element (M1 i c f a) -> Element (M1 i c f a)) -> M1 i c f a -> Element (M1 i c f a) #

headEx :: M1 i c f a -> Element (M1 i c f a) #

lastEx :: M1 i c f a -> Element (M1 i c f a) #

unsafeHead :: M1 i c f a -> Element (M1 i c f a) #

unsafeLast :: M1 i c f a -> Element (M1 i c f a) #

maximumByEx :: (Element (M1 i c f a) -> Element (M1 i c f a) -> Ordering) -> M1 i c f a -> Element (M1 i c f a) #

minimumByEx :: (Element (M1 i c f a) -> Element (M1 i c f a) -> Ordering) -> M1 i c f a -> Element (M1 i c f a) #

oelem :: Element (M1 i c f a) -> M1 i c f a -> Bool #

onotElem :: Element (M1 i c f a) -> M1 i c f a -> Bool #

headMay :: MonoFoldable mono => mono -> Maybe (Element mono) #

Safe version of `headEx`.

Returns `Nothing` instead of throwing an exception when encountering an empty monomorphic container.

lastMay :: MonoFoldable mono => mono -> Maybe (Element mono) #

Safe version of `lastEx`.

Returns `Nothing` instead of throwing an exception when encountering an empty monomorphic container.

osum :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono #

`osum` computes the sum of the numbers of a monomorphic container.

oproduct :: (MonoFoldable mono, Num (Element mono)) => mono -> Element mono #

`oproduct` computes the product of the numbers of a monomorphic container.

oand :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool #

Are all of the elements `True`?

Since: 0.6.0

oor :: (Element mono ~ Bool, MonoFoldable mono) => mono -> Bool #

Are any of the elements `True`?

Since: 0.6.0

oconcatMap :: (MonoFoldable mono, Monoid m) => (Element mono -> m) -> mono -> m #

Synonym for `ofoldMap`

Since: 1.0.0

ofold :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono #

Monoidally combine all values in the container

Since: 1.0.0

oconcat :: (MonoFoldable mono, Monoid (Element mono)) => mono -> Element mono #

Synonym for `ofold`

Since: 1.0.0

ofoldM :: (MonoFoldable mono, Monad m) => (a -> Element mono -> m a) -> a -> mono -> m a #

Synonym for `ofoldlM`

Since: 1.0.0

osequence_ :: (Applicative m, MonoFoldable mono, Element mono ~ m ()) => mono -> m () #

Perform all actions in the given container

Since: 1.0.0

maximumEx :: (MonoFoldable mono, Ord (Element mono)) => mono -> Element mono #

Get the minimum element of a monomorphic container.

Note: this is a partial function. On an empty `MonoFoldable`, it will throw an exception.

See `maximum` from Data.NonNull for a total version of this function.

minimumEx :: (MonoFoldable mono, Ord (Element mono)) => mono -> Element mono #

Get the maximum element of a monomorphic container.

Note: this is a partial function. On an empty `MonoFoldable`, it will throw an exception.

See `minimum` from Data.NonNull for a total version of this function.

maximumMay :: (MonoFoldable mono, Ord (Element mono)) => mono -> Maybe (Element mono) #

Safe version of `maximumEx`.

Returns `Nothing` instead of throwing an exception when encountering an empty monomorphic container.

maximumByMay :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Maybe (Element mono) #

Safe version of `maximumByEx`.

Returns `Nothing` instead of throwing an exception when encountering an empty monomorphic container.

minimumMay :: (MonoFoldable mono, Ord (Element mono)) => mono -> Maybe (Element mono) #

Safe version of `minimumEx`.

Returns `Nothing` instead of throwing an exception when encountering an empty monomorphic container.

minimumByMay :: MonoFoldable mono => (Element mono -> Element mono -> Ordering) -> mono -> Maybe (Element mono) #

Safe version of `minimumByEx`.

Returns `Nothing` instead of throwing an exception when encountering an empty monomorphic container.

class (MonoFunctor mono, MonoFoldable mono) => MonoTraversable mono where #

Monomorphic containers that can be traversed from left to right.

NOTE: Due to limitations with the role system, GHC is yet unable to provide newtype-derivation of `MonoTraversable`. See https://stackoverflow.com/questions/49776924/newtype-deriving-issequence.

Minimal complete definition

Nothing

Methods

otraverse :: Applicative f => (Element mono -> f (Element mono)) -> mono -> f mono #

Map each element of a monomorphic container to an action, evaluate these actions from left to right, and collect the results.

default otraverse :: (Traversable t, mono ~ t a, a ~ Element mono, Applicative f) => (Element mono -> f (Element mono)) -> mono -> f mono #

omapM :: Applicative m => (Element mono -> m (Element mono)) -> mono -> m mono #

Map each element of a monomorphic container to a monadic action, evaluate these actions from left to right, and collect the results.

#### Instances

Instances details

MonoTraversable ByteString # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element ByteString -> f (Element ByteString)) -> ByteString -> f ByteString # omapM :: Applicative m => (Element ByteString -> m (Element ByteString)) -> ByteString -> m ByteString #
MonoTraversable ByteString # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element ByteString -> f (Element ByteString)) -> ByteString -> f ByteString # omapM :: Applicative m => (Element ByteString -> m (Element ByteString)) -> ByteString -> m ByteString #
MonoTraversable Text # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element Text -> f (Element Text)) -> Text -> f Text # omapM :: Applicative m => (Element Text -> m (Element Text)) -> Text -> m Text #
MonoTraversable Text # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element Text -> f (Element Text)) -> Text -> f Text # omapM :: Applicative m => (Element Text -> m (Element Text)) -> Text -> m Text #
MonoTraversable (Identity a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Identity a) -> f (Element (Identity a))) -> Identity a -> f (Identity a) # omapM :: Applicative m => (Element (Identity a) -> m (Element (Identity a))) -> Identity a -> m (Identity a) #
MonoTraversable (NonEmpty a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (NonEmpty a) -> f (Element (NonEmpty a))) -> NonEmpty a -> f (NonEmpty a) # omapM :: Applicative m => (Element (NonEmpty a) -> m (Element (NonEmpty a))) -> NonEmpty a -> m (NonEmpty a) #
MonoTraversable (Par1 a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Par1 a) -> f (Element (Par1 a))) -> Par1 a -> f (Par1 a) # omapM :: Applicative m => (Element (Par1 a) -> m (Element (Par1 a))) -> Par1 a -> m (Par1 a) #
MonoTraversable (IntMap a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (IntMap a) -> f (Element (IntMap a))) -> IntMap a -> f (IntMap a) # omapM :: Applicative m => (Element (IntMap a) -> m (Element (IntMap a))) -> IntMap a -> m (IntMap a) #
MonoTraversable (Seq a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Seq a) -> f (Element (Seq a))) -> Seq a -> f (Seq a) # omapM :: Applicative m => (Element (Seq a) -> m (Element (Seq a))) -> Seq a -> m (Seq a) #
MonoTraversable (ViewL a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (ViewL a) -> f (Element (ViewL a))) -> ViewL a -> f (ViewL a) # omapM :: Applicative m => (Element (ViewL a) -> m (Element (ViewL a))) -> ViewL a -> m (ViewL a) #
MonoTraversable (ViewR a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (ViewR a) -> f (Element (ViewR a))) -> ViewR a -> f (ViewR a) # omapM :: Applicative m => (Element (ViewR a) -> m (Element (ViewR a))) -> ViewR a -> m (ViewR a) #
MonoTraversable (Tree a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Tree a) -> f (Element (Tree a))) -> Tree a -> f (Tree a) # omapM :: Applicative m => (Element (Tree a) -> m (Element (Tree a))) -> Tree a -> m (Tree a) #
MonoTraversable mono => MonoTraversable (NonNull mono) # |
Instance details Defined in Data.NonNull Methods otraverse :: Applicative f => (Element (NonNull mono) -> f (Element (NonNull mono))) -> NonNull mono -> f (NonNull mono) # omapM :: Applicative m => (Element (NonNull mono) -> m (Element (NonNull mono))) -> NonNull mono -> m (NonNull mono) #
MonoTraversable (Vector a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Vector a) -> f (Element (Vector a))) -> Vector a -> f (Vector a) # omapM :: Applicative m => (Element (Vector a) -> m (Element (Vector a))) -> Vector a -> m (Vector a) #
Storable a => MonoTraversable (Vector a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Vector a) -> f (Element (Vector a))) -> Vector a -> f (Vector a) # omapM :: Applicative m => (Element (Vector a) -> m (Element (Vector a))) -> Vector a -> m (Vector a) #
Unbox a => MonoTraversable (Vector a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Vector a) -> f (Element (Vector a))) -> Vector a -> f (Vector a) # omapM :: Applicative m => (Element (Vector a) -> m (Element (Vector a))) -> Vector a -> m (Vector a) #
MonoTraversable (Maybe a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Maybe a) -> f (Element (Maybe a))) -> Maybe a -> f (Maybe a) # omapM :: Applicative m => (Element (Maybe a) -> m (Element (Maybe a))) -> Maybe a -> m (Maybe a) #
MonoTraversable [a] # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element [a] -> f (Element [a])) -> [a] -> f [a] # omapM :: Applicative m => (Element [a] -> m (Element [a])) -> [a] -> m [a] #
MonoTraversable (Either a b) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Either a b) -> f (Element (Either a b))) -> Either a b -> f (Either a b) # omapM :: Applicative m => (Element (Either a b) -> m (Element (Either a b))) -> Either a b -> m (Either a b) #
MonoTraversable (Proxy a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Proxy a) -> f (Element (Proxy a))) -> Proxy a -> f (Proxy a) # omapM :: Applicative m => (Element (Proxy a) -> m (Element (Proxy a))) -> Proxy a -> m (Proxy a) #
MonoTraversable (U1 a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (U1 a) -> f (Element (U1 a))) -> U1 a -> f (U1 a) # omapM :: Applicative m => (Element (U1 a) -> m (Element (U1 a))) -> U1 a -> m (U1 a) #
MonoTraversable (V1 a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (V1 a) -> f (Element (V1 a))) -> V1 a -> f (V1 a) # omapM :: Applicative m => (Element (V1 a) -> m (Element (V1 a))) -> V1 a -> m (V1 a) #
MonoTraversable (Map k v) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Map k v) -> f (Element (Map k v))) -> Map k v -> f (Map k v) # omapM :: Applicative m => (Element (Map k v) -> m (Element (Map k v))) -> Map k v -> m (Map k v) #
Traversable f => MonoTraversable (MaybeT f a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element (MaybeT f a) -> f0 (Element (MaybeT f a))) -> MaybeT f a -> f0 (MaybeT f a) # omapM :: Applicative m => (Element (MaybeT f a) -> m (Element (MaybeT f a))) -> MaybeT f a -> m (MaybeT f a) #
MonoTraversable (HashMap k v) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (HashMap k v) -> f (Element (HashMap k v))) -> HashMap k v -> f (HashMap k v) # omapM :: Applicative m => (Element (HashMap k v) -> m (Element (HashMap k v))) -> HashMap k v -> m (HashMap k v) #
MonoTraversable (a, b) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (a, b) -> f (Element (a, b))) -> (a, b) -> f (a, b) # omapM :: Applicative m => (Element (a, b) -> m (Element (a, b))) -> (a, b) -> m (a, b) #
MonoTraversable (Const m a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (Const m a) -> f (Element (Const m a))) -> Const m a -> f (Const m a) # omapM :: Applicative m0 => (Element (Const m a) -> m0 (Element (Const m a))) -> Const m a -> m0 (Const m a) #
Traversable f => MonoTraversable (Rec1 f a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element (Rec1 f a) -> f0 (Element (Rec1 f a))) -> Rec1 f a -> f0 (Rec1 f a) # omapM :: Applicative m => (Element (Rec1 f a) -> m (Element (Rec1 f a))) -> Rec1 f a -> m (Rec1 f a) #
Traversable f => MonoTraversable (IdentityT f a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element (IdentityT f a) -> f0 (Element (IdentityT f a))) -> IdentityT f a -> f0 (IdentityT f a) # omapM :: Applicative m => (Element (IdentityT f a) -> m (Element (IdentityT f a))) -> IdentityT f a -> m (IdentityT f a) #
Traversable f => MonoTraversable (WriterT w f a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element (WriterT w f a) -> f0 (Element (WriterT w f a))) -> WriterT w f a -> f0 (WriterT w f a) # omapM :: Applicative m => (Element (WriterT w f a) -> m (Element (WriterT w f a))) -> WriterT w f a -> m (WriterT w f a) #
Traversable f => MonoTraversable (WriterT w f a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element (WriterT w f a) -> f0 (Element (WriterT w f a))) -> WriterT w f a -> f0 (WriterT w f a) # omapM :: Applicative m => (Element (WriterT w f a) -> m (Element (WriterT w f a))) -> WriterT w f a -> m (WriterT w f a) #
(Traversable f, Traversable g) => MonoTraversable (Product f g a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element (Product f g a) -> f0 (Element (Product f g a))) -> Product f g a -> f0 (Product f g a) # omapM :: Applicative m => (Element (Product f g a) -> m (Element (Product f g a))) -> Product f g a -> m (Product f g a) #
(Traversable f, Traversable g) => MonoTraversable ((f :*: g) a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element ((f :*: g) a) -> f0 (Element ((f :*: g) a))) -> (f :*: g) a -> f0 ((f :*: g) a) # omapM :: Applicative m => (Element ((f :*: g) a) -> m (Element ((f :*: g) a))) -> (f :*: g) a -> m ((f :*: g) a) #
(Traversable f, Traversable g) => MonoTraversable ((f :+: g) a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element ((f :+: g) a) -> f0 (Element ((f :+: g) a))) -> (f :+: g) a -> f0 ((f :+: g) a) # omapM :: Applicative m => (Element ((f :+: g) a) -> m (Element ((f :+: g) a))) -> (f :+: g) a -> m ((f :+: g) a) #
MonoTraversable (K1 i c a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f => (Element (K1 i c a) -> f (Element (K1 i c a))) -> K1 i c a -> f (K1 i c a) # omapM :: Applicative m => (Element (K1 i c a) -> m (Element (K1 i c a))) -> K1 i c a -> m (K1 i c a) #
(Traversable f, Traversable g) => MonoTraversable (Compose f g a) # |
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element (Compose f g a) -> f0 (Element (Compose f g a))) -> Compose f g a -> f0 (Compose f g a) # omapM :: Applicative m => (Element (Compose f g a) -> m (Element (Compose f g a))) -> Compose f g a -> m (Compose f g a) #
(Traversable f, Traversable g) => MonoTraversable ((f :.: g) a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element ((f :.: g) a) -> f0 (Element ((f :.: g) a))) -> (f :.: g) a -> f0 ((f :.: g) a) # omapM :: Applicative m => (Element ((f :.: g) a) -> m (Element ((f :.: g) a))) -> (f :.: g) a -> m ((f :.: g) a) #
Traversable f => MonoTraversable (M1 i c f a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods otraverse :: Applicative f0 => (Element (M1 i c f a) -> f0 (Element (M1 i c f a))) -> M1 i c f a -> f0 (M1 i c f a) # omapM :: Applicative m => (Element (M1 i c f a) -> m (Element (M1 i c f a))) -> M1 i c f a -> m (M1 i c f a) #

ofor :: (MonoTraversable mono, Applicative f) => mono -> (Element mono -> f (Element mono)) -> f mono #

`ofor` is `otraverse` with its arguments flipped.

oforM :: (MonoTraversable mono, Applicative f) => mono -> (Element mono -> f (Element mono)) -> f mono #

`oforM` is `omapM` with its arguments flipped.

ofoldlUnwrap :: MonoFoldable mono => (x -> Element mono -> x) -> x -> (x -> b) -> mono -> b #

A strict left fold, together with an unwrap function.

This is convenient when the accumulator value is not the same as the final expected type. It is provided mainly for integration with the `foldl` package, to be used in conjunction with `purely`.

Since: 0.3.1

ofoldMUnwrap :: (Monad m, MonoFoldable mono) => (x -> Element mono -> m x) -> m x -> (x -> m b) -> mono -> m b #

A monadic strict left fold, together with an unwrap function.

Similar to `foldlUnwrap`, but allows monadic actions. To be used with `impurely` from `foldl`.

Since: 0.3.1

class MonoPointed mono where #

Typeclass for monomorphic containers that an element can be lifted into.

For any `MonoFunctor`, the following law holds:

    omap f . opoint = opoint . f

Minimal complete definition

Nothing

Methods

opoint :: Element mono -> mono #

Lift an element into a monomorphic container.

`opoint` is the same as `pure` for an `Applicative`

default opoint :: (Applicative f, f a ~ mono, Element (f a) ~ a) => Element mono -> mono #

#### Instances

Instances details

MonoPointed ByteString # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element ByteString -> ByteString #
MonoPointed ByteString # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element ByteString -> ByteString #
MonoPointed IntSet # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element IntSet -> IntSet #
MonoPointed Text # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element Text -> Text #
MonoPointed Text # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element Text -> Text #
MonoPointed (ZipList a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (ZipList a) -> ZipList a #
MonoPointed (Identity a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Identity a) -> Identity a #
MonoPointed (NonEmpty a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (NonEmpty a) -> NonEmpty a #
MonoPointed (Par1 a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Par1 a) -> Par1 a #
MonoPointed (Seq a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Seq a) -> Seq a #
MonoPointed (ViewL a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (ViewL a) -> ViewL a #
MonoPointed (ViewR a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (ViewR a) -> ViewR a #
MonoPointed (Set a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Set a) -> Set a #
MonoPointed (Tree a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Tree a) -> Tree a #
MonoPointed (IO a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (IO a) -> IO a #
MonoPointed mono => MonoPointed (NonNull mono) # |
Instance details Defined in Data.NonNull Methods opoint :: Element (NonNull mono) -> NonNull mono #
Hashable a => MonoPointed (HashSet a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (HashSet a) -> HashSet a #
MonoPointed (Vector a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Vector a) -> Vector a #
Storable a => MonoPointed (Vector a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Vector a) -> Vector a #
Unbox a => MonoPointed (Vector a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Vector a) -> Vector a #
MonoPointed (Maybe a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Maybe a) -> Maybe a #
MonoPointed [a] # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element [a] -> [a] #
Monad m => MonoPointed (WrappedMonad m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (WrappedMonad m a) -> WrappedMonad m a #
MonoPointed (Either a b) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Either a b) -> Either a b #
MonoPointed (Proxy a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Proxy a) -> Proxy a #
MonoPointed (U1 a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (U1 a) -> U1 a #
(MonoPointed mono, Element mono ~ a) => MonoPointed (WrappedMono mono a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (WrappedMono mono a) -> WrappedMono mono a #
Applicative f => MonoPointed (WrappedPoly f a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (WrappedPoly f a) -> WrappedPoly f a #
Applicative f => MonoPointed (MaybeT f a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (MaybeT f a) -> MaybeT f a #
Monoid a => MonoPointed (a, b) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (a, b) -> (a, b) #
MonoPointed (r -> a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (r -> a) -> r -> a #
Arrow a => MonoPointed (WrappedArrow a b c) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (WrappedArrow a b c) -> WrappedArrow a b c #
Monoid m => MonoPointed (Const m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Const m a) -> Const m a #
Applicative f => MonoPointed (Rec1 f a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Rec1 f a) -> Rec1 f a #
Applicative m => MonoPointed (IdentityT m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (IdentityT m a) -> IdentityT m a #
Applicative m => MonoPointed (ReaderT r m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (ReaderT r m a) -> ReaderT r m a #
Applicative m => MonoPointed (StateT s m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (StateT s m a) -> StateT s m a #
Applicative m => MonoPointed (StateT s m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (StateT s m a) -> StateT s m a #
(Monoid w, Applicative m) => MonoPointed (WriterT w m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (WriterT w m a) -> WriterT w m a #
(Monoid w, Applicative m) => MonoPointed (WriterT w m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (WriterT w m a) -> WriterT w m a #
(Applicative f, Applicative g) => MonoPointed (Product f g a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Product f g a) -> Product f g a #
(Applicative f, Applicative g) => MonoPointed ((f :*: g) a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods opoint :: Element ((f :*: g) a) -> (f :*: g) a #
(Applicative f, Applicative g) => MonoPointed ((f :+: g) a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods opoint :: Element ((f :+: g) a) -> (f :+: g) a #
MonoPointed (ContT r m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (ContT r m a) -> ContT r m a #
(Applicative f, Applicative g) => MonoPointed (Compose f g a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (Compose f g a) -> Compose f g a #
(Applicative f, Applicative g) => MonoPointed ((f :.: g) a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods opoint :: Element ((f :.: g) a) -> (f :.: g) a #
Applicative f => MonoPointed (M1 i c f a) # | Since: 1.0.11.0
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (M1 i c f a) -> M1 i c f a #
(Monoid w, Applicative m) => MonoPointed (RWST r w s m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (RWST r w s m a) -> RWST r w s m a #
(Monoid w, Applicative m) => MonoPointed (RWST r w s m a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (RWST r w s m a) -> RWST r w s m a #

class MonoFunctor mono => MonoComonad mono where #

Typeclass for monomorphic containers where it is always okay to "extract" a value from with `oextract`, and where you can extrapolate any "extracting" function to be a function on the whole part with `oextend`.

`oextend` and `oextract` should work together following the laws:

    oextend oextract      = id
    oextract . oextend f  = f
    oextend f . oextend g = oextend (f . oextend g)

As an intuition, ``oextend` f` uses `f` to "build up" a new `mono` with pieces from the old one received by `f`.

Methods

oextract :: mono -> Element mono #

Extract an element from `mono`. Can be thought of as a dual concept to `opoint`.

oextend :: (mono -> Element mono) -> mono -> mono #

Extend a `mono -> `Element` mono` function to be a `mono -> mono`; that is, builds a new `mono` from the old one by using pieces glimpsed from the given function.

#### Instances

Instances details

MonoComonad (ViewL a) # |
Instance details Defined in Data.MonoTraversable Methods oextract :: ViewL a -> Element (ViewL a) # oextend :: (ViewL a -> Element (ViewL a)) -> ViewL a -> ViewL a #
MonoComonad (ViewR a) # |
Instance details Defined in Data.MonoTraversable Methods oextract :: ViewR a -> Element (ViewR a) # oextend :: (ViewR a -> Element (ViewR a)) -> ViewR a -> ViewR a #
IsSequence mono => MonoComonad (NonNull mono) # |
Instance details Defined in Data.NonNull Methods oextract :: NonNull mono -> Element (NonNull mono) # oextend :: (NonNull mono -> Element (NonNull mono)) -> NonNull mono -> NonNull mono #

class MonoFoldable mono => GrowingAppend mono #

Containers which, when two values are combined, the combined length is no less than the larger of the two inputs. In code:

    olength (x <> y) >= max (olength x) (olength y)

This class has no methods, and is simply used to assert that this law holds, in order to provide guarantees of correctness (see, for instance, Data.NonNull).

This should have a `Semigroup` superclass constraint, however, due to `Semigroup` only recently moving to base, some packages do not provide instances.

#### Instances

Instances details

GrowingAppend ByteString # |
Instance details Defined in Data.MonoTraversable
GrowingAppend ByteString # |
Instance details Defined in Data.MonoTraversable
GrowingAppend IntSet # |
Instance details Defined in Data.MonoTraversable
GrowingAppend Text # |
Instance details Defined in Data.MonoTraversable
GrowingAppend Text # |
Instance details Defined in Data.MonoTraversable
GrowingAppend (NonEmpty a) # |
Instance details Defined in Data.MonoTraversable
GrowingAppend (IntMap v) # |
Instance details Defined in Data.MonoTraversable
GrowingAppend (Seq a) # |
Instance details Defined in Data.MonoTraversable
Ord v => GrowingAppend (Set v) # |
Instance details Defined in Data.MonoTraversable
GrowingAppend mono => GrowingAppend (NonNull mono) # |
Instance details Defined in Data.NonNull
(Eq v, Hashable v) => GrowingAppend (HashSet v) # |
Instance details Defined in Data.MonoTraversable
GrowingAppend (Vector a) # |
Instance details Defined in Data.MonoTraversable
Storable a => GrowingAppend (Vector a) # |
Instance details Defined in Data.MonoTraversable
Unbox a => GrowingAppend (Vector a) # |
Instance details Defined in Data.MonoTraversable
GrowingAppend [a] # |
Instance details Defined in Data.MonoTraversable
Ord k => GrowingAppend (Map k v) # |
Instance details Defined in Data.MonoTraversable
(Eq k, Hashable k) => GrowingAppend (HashMap k v) # |
Instance details Defined in Data.MonoTraversable

ointercalate :: (MonoFoldable mono, Monoid (Element mono)) => Element mono -> mono -> Element mono #

`intercalate` `seq seqs` inserts `seq` in between `seqs` and concatenates the result.

Since: 1.0.0

newtype WrappedPoly f a #

Provides a `MonoFoldable`, `MonoFunctor` or `MonoPointed` for an arbitrary `Foldable`, `Functor` or `Applicative`.

Useful for, e.g., passing a `Foldable` type you don't own into a function that expects a `MonoFoldable`.

    // package A
    data MyList a = MyList [a] deriving Foldable

    // package B
    process :: MonoFoldable mono => mono -> IO ()

    // package C
    process (WrappedPoly (MyList []))

Since: 1.0.13.0

Constructors

WrappedPoly |

Fields

- unwrapPoly :: f a

#### Instances

Instances details

Foldable f => Foldable (WrappedPoly f) # |

Instance details

Defined in Data.MonoTraversable

Methods

fold :: Monoid m => WrappedPoly f m -> m

foldMap :: Monoid m => (a -> m) -> WrappedPoly f a -> m

foldMap' :: Monoid m => (a -> m) -> WrappedPoly f a -> m

foldr :: (a -> b -> b) -> b -> WrappedPoly f a -> b

foldr' :: (a -> b -> b) -> b -> WrappedPoly f a -> b

foldl :: (b -> a -> b) -> b -> WrappedPoly f a -> b

foldl' :: (b -> a -> b) -> b -> WrappedPoly f a -> b

foldr1 :: (a -> a -> a) -> WrappedPoly f a -> a

foldl1 :: (a -> a -> a) -> WrappedPoly f a -> a

toList :: WrappedPoly f a -> [a]

null :: WrappedPoly f a -> Bool

length :: WrappedPoly f a -> Int

elem :: Eq a => a -> WrappedPoly f a -> Bool

maximum :: Ord a => WrappedPoly f a -> a

minimum :: Ord a => WrappedPoly f a -> a

sum :: Num a => WrappedPoly f a -> a

product :: Num a => WrappedPoly f a -> a

Applicative f => Applicative (WrappedPoly f) # |
Instance details Defined in Data.MonoTraversable Methods pure :: a -> WrappedPoly f a (<*>) :: WrappedPoly f (a -> b) -> WrappedPoly f a -> WrappedPoly f b liftA2 :: (a -> b -> c) -> WrappedPoly f a -> WrappedPoly f b -> WrappedPoly f c (*>) :: WrappedPoly f a -> WrappedPoly f b -> WrappedPoly f b (<*) :: WrappedPoly f a -> WrappedPoly f b -> WrappedPoly f a
Functor f => Functor (WrappedPoly f) # |
Instance details Defined in Data.MonoTraversable Methods fmap :: (a -> b) -> WrappedPoly f a -> WrappedPoly f b (<$) :: a -> WrappedPoly f b -> WrappedPoly f a
Monad f => Monad (WrappedPoly f) # |
Instance details Defined in Data.MonoTraversable Methods (>>=) :: WrappedPoly f a -> (a -> WrappedPoly f b) -> WrappedPoly f b (>>) :: WrappedPoly f a -> WrappedPoly f b -> WrappedPoly f b return :: a -> WrappedPoly f a
Foldable f => MonoFoldable (WrappedPoly f a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (WrappedPoly f a) -> m) -> WrappedPoly f a -> m #

ofoldr :: (Element (WrappedPoly f a) -> b -> b) -> b -> WrappedPoly f a -> b #

ofoldl' :: (a0 -> Element (WrappedPoly f a) -> a0) -> a0 -> WrappedPoly f a -> a0 #

otoList :: WrappedPoly f a -> [Element (WrappedPoly f a)] #

oall :: (Element (WrappedPoly f a) -> Bool) -> WrappedPoly f a -> Bool #

oany :: (Element (WrappedPoly f a) -> Bool) -> WrappedPoly f a -> Bool #

onull :: WrappedPoly f a -> Bool #

olength :: WrappedPoly f a -> Int #

olength64 :: WrappedPoly f a -> Int64 #

ocompareLength :: Integral i => WrappedPoly f a -> i -> Ordering #

otraverse_ :: Applicative f0 => (Element (WrappedPoly f a) -> f0 b) -> WrappedPoly f a -> f0 () #

ofor_ :: Applicative f0 => WrappedPoly f a -> (Element (WrappedPoly f a) -> f0 b) -> f0 () #

omapM_ :: Applicative m => (Element (WrappedPoly f a) -> m ()) -> WrappedPoly f a -> m () #

oforM_ :: Applicative m => WrappedPoly f a -> (Element (WrappedPoly f a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (WrappedPoly f a) -> m a0) -> a0 -> WrappedPoly f a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (WrappedPoly f a) -> m) -> WrappedPoly f a -> m #

ofoldr1Ex :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a) -> Element (WrappedPoly f a)) -> WrappedPoly f a -> Element (WrappedPoly f a) #

ofoldl1Ex' :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a) -> Element (WrappedPoly f a)) -> WrappedPoly f a -> Element (WrappedPoly f a) #

headEx :: WrappedPoly f a -> Element (WrappedPoly f a) #

lastEx :: WrappedPoly f a -> Element (WrappedPoly f a) #

unsafeHead :: WrappedPoly f a -> Element (WrappedPoly f a) #

unsafeLast :: WrappedPoly f a -> Element (WrappedPoly f a) #

maximumByEx :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a) -> Ordering) -> WrappedPoly f a -> Element (WrappedPoly f a) #

minimumByEx :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a) -> Ordering) -> WrappedPoly f a -> Element (WrappedPoly f a) #

oelem :: Element (WrappedPoly f a) -> WrappedPoly f a -> Bool #

onotElem :: Element (WrappedPoly f a) -> WrappedPoly f a -> Bool #

Functor f => MonoFunctor (WrappedPoly f a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (WrappedPoly f a) -> Element (WrappedPoly f a)) -> WrappedPoly f a -> WrappedPoly f a #
Applicative f => MonoPointed (WrappedPoly f a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (WrappedPoly f a) -> WrappedPoly f a #
type Element (WrappedPoly f a) # |
Instance details Defined in Data.MonoTraversable type Element (WrappedPoly f a) = a

data WrappedMono mono a where #

Provides a `Foldable` for an arbitrary `MonoFoldable`.

Since: 1.0.14.0

Constructors

WrappedMono :: Element mono ~ a => mono -> WrappedMono mono a |

#### Instances

Instances details

MonoFoldable mono => Foldable (WrappedMono mono) # |

Instance details

Defined in Data.MonoTraversable

Methods

fold :: Monoid m => WrappedMono mono m -> m

foldMap :: Monoid m => (a -> m) -> WrappedMono mono a -> m

foldMap' :: Monoid m => (a -> m) -> WrappedMono mono a -> m

foldr :: (a -> b -> b) -> b -> WrappedMono mono a -> b

foldr' :: (a -> b -> b) -> b -> WrappedMono mono a -> b

foldl :: (b -> a -> b) -> b -> WrappedMono mono a -> b

foldl' :: (b -> a -> b) -> b -> WrappedMono mono a -> b

foldr1 :: (a -> a -> a) -> WrappedMono mono a -> a

foldl1 :: (a -> a -> a) -> WrappedMono mono a -> a

toList :: WrappedMono mono a -> [a]

null :: WrappedMono mono a -> Bool

length :: WrappedMono mono a -> Int

elem :: Eq a => a -> WrappedMono mono a -> Bool

maximum :: Ord a => WrappedMono mono a -> a

minimum :: Ord a => WrappedMono mono a -> a

sum :: Num a => WrappedMono mono a -> a

product :: Num a => WrappedMono mono a -> a

MonoFoldable mono => MonoFoldable (WrappedMono mono a) # |

Instance details

Defined in Data.MonoTraversable

Methods

ofoldMap :: Monoid m => (Element (WrappedMono mono a) -> m) -> WrappedMono mono a -> m #

ofoldr :: (Element (WrappedMono mono a) -> b -> b) -> b -> WrappedMono mono a -> b #

ofoldl' :: (a0 -> Element (WrappedMono mono a) -> a0) -> a0 -> WrappedMono mono a -> a0 #

otoList :: WrappedMono mono a -> [Element (WrappedMono mono a)] #

oall :: (Element (WrappedMono mono a) -> Bool) -> WrappedMono mono a -> Bool #

oany :: (Element (WrappedMono mono a) -> Bool) -> WrappedMono mono a -> Bool #

onull :: WrappedMono mono a -> Bool #

olength :: WrappedMono mono a -> Int #

olength64 :: WrappedMono mono a -> Int64 #

ocompareLength :: Integral i => WrappedMono mono a -> i -> Ordering #

otraverse_ :: Applicative f => (Element (WrappedMono mono a) -> f b) -> WrappedMono mono a -> f () #

ofor_ :: Applicative f => WrappedMono mono a -> (Element (WrappedMono mono a) -> f b) -> f () #

omapM_ :: Applicative m => (Element (WrappedMono mono a) -> m ()) -> WrappedMono mono a -> m () #

oforM_ :: Applicative m => WrappedMono mono a -> (Element (WrappedMono mono a) -> m ()) -> m () #

ofoldlM :: Monad m => (a0 -> Element (WrappedMono mono a) -> m a0) -> a0 -> WrappedMono mono a -> m a0 #

ofoldMap1Ex :: Semigroup m => (Element (WrappedMono mono a) -> m) -> WrappedMono mono a -> m #

ofoldr1Ex :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a) -> Element (WrappedMono mono a)) -> WrappedMono mono a -> Element (WrappedMono mono a) #

ofoldl1Ex' :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a) -> Element (WrappedMono mono a)) -> WrappedMono mono a -> Element (WrappedMono mono a) #

headEx :: WrappedMono mono a -> Element (WrappedMono mono a) #

lastEx :: WrappedMono mono a -> Element (WrappedMono mono a) #

unsafeHead :: WrappedMono mono a -> Element (WrappedMono mono a) #

unsafeLast :: WrappedMono mono a -> Element (WrappedMono mono a) #

maximumByEx :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a) -> Ordering) -> WrappedMono mono a -> Element (WrappedMono mono a) #

minimumByEx :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a) -> Ordering) -> WrappedMono mono a -> Element (WrappedMono mono a) #

oelem :: Element (WrappedMono mono a) -> WrappedMono mono a -> Bool #

onotElem :: Element (WrappedMono mono a) -> WrappedMono mono a -> Bool #

MonoFunctor mono => MonoFunctor (WrappedMono mono a) # |
Instance details Defined in Data.MonoTraversable Methods omap :: (Element (WrappedMono mono a) -> Element (WrappedMono mono a)) -> WrappedMono mono a -> WrappedMono mono a #
(MonoPointed mono, Element mono ~ a) => MonoPointed (WrappedMono mono a) # |
Instance details Defined in Data.MonoTraversable Methods opoint :: Element (WrappedMono mono a) -> WrappedMono mono a #
type Element (WrappedMono mono a) # |
Instance details Defined in Data.MonoTraversable type Element (WrappedMono mono a) = Element mono

unwrapMono :: WrappedMono mono a -> mono #

Unwraps a `WrappedMono`.

Since: 1.0.14.0