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

Safe Haskell | None
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
- 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
- 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 ()
- oelem :: (MonoFoldable mono, Eq (Element mono)) => Element mono -> mono -> Bool
- onotElem :: (MonoFoldable mono, Eq (Element mono)) => Element mono -> mono -> Bool
- 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
- 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
- class MonoFunctor mono => MonoComonad mono where
- class MonoFoldable mono => GrowingAppend mono
- ointercalate :: (MonoFoldable mono, Monoid (Element mono)) => Element mono -> mono -> Element mono

# Documentation

type family Element mono #

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

Instances

type Element ByteString # |
type Element ByteString = Word8
type Element ByteString # |
type Element ByteString = Word8
type Element IntSet # |
type Element IntSet = Int
type Element Text # |
type Element Text = Char
type Element Text # |
type Element Text = Char
type Element [a] # |
type Element [a] = a
type Element (Maybe a) # |
type Element (Maybe a) = a
type Element (IO a) # |
type Element (IO a) = a
type Element (Identity a) # |
type Element (Identity a) = a
type Element (Option a) # |
type Element (Option a) = a
type Element (NonEmpty a) # |
type Element (NonEmpty a) = a
type Element (ZipList a) # |
type Element (ZipList a) = a
type Element (Tree a) # |
type Element (Tree a) = a
type Element (Seq a) # |
type Element (Seq a) = a
type Element (ViewL a) # |
type Element (ViewL a) = a
type Element (ViewR a) # |
type Element (ViewR a) = a
type Element (IntMap a) # |
type Element (IntMap a) = a
type Element (Set e) # |
type Element (Set e) = e
type Element (HashSet e) # |
type Element (HashSet e) = e
type Element (Vector a) # |
type Element (Vector a) = a
type Element (Vector a) # |
type Element (Vector a) = a
type Element (Vector a) # |
type Element (Vector a) = a
type Element (NonNull mono) # |
type Element (NonNull mono) = Element mono
type Element (r -> a) # |
type Element (r -> a) = a
type Element (Either a b) # |
type Element (Either a b) = b
type Element (a, b) # |
type Element (a, b) = b
type Element (Arg a b) # |
type Element (Arg a b) = b
type Element (WrappedMonad m a) # |
type Element (WrappedMonad m a) = a
type Element (Map k v) # |
type Element (Map k v) = v
type Element (MaybeT m a) # |
type Element (MaybeT m a) = a
type Element (ListT m a) # |
type Element (ListT m a) = a
type Element (HashMap k v) # |
type Element (HashMap k v) = v
type Element (WrappedArrow a b c) # |
type Element (WrappedArrow a b c) = c
type Element (Const * m a) # |
type Element (Const * m a) = a
type Element (WriterT w m a) # |
type Element (WriterT w m a) = a
type Element (WriterT w m a) # |
type Element (WriterT w m a) = a
type Element (StateT s m a) # |
type Element (StateT s m a) = a
type Element (StateT s m a) # |
type Element (StateT s m a) = a
type Element (IdentityT * m a) # |
type Element (IdentityT * m a) = a
type Element (Product * f g a) # |
type Element (Product * f g a) = a
type Element (ReaderT * r m a) # |
type Element (ReaderT * r m a) = a
type Element (ContT * r m a) # |
type Element (ContT * r m a) = a
type Element (Compose * * f g a) # |
type Element (Compose * * f g a) = a
type Element (RWST r w s m a) # |
type Element (RWST r w s m a) = a
type Element (RWST r w s m a) # |
type Element (RWST r w s m a) = a

class MonoFunctor mono where #

Monomorphic containers that can be mapped over.

Methods

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

Map over a monomorphic container

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

Map over a monomorphic container

Instances

MonoFunctor ByteString # |
Methods omap :: (Element ByteString -> Element ByteString) -> ByteString -> ByteString #
MonoFunctor ByteString # |
Methods omap :: (Element ByteString -> Element ByteString) -> ByteString -> ByteString #
MonoFunctor Text # |
Methods omap :: (Element Text -> Element Text) -> Text -> Text #
MonoFunctor Text # |
Methods omap :: (Element Text -> Element Text) -> Text -> Text #
MonoFunctor [a] # |
Methods omap :: (Element [a] -> Element [a]) -> [a] -> [a] #
MonoFunctor (Maybe a) # |
Methods omap :: (Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe a #
MonoFunctor (IO a) # |
Methods omap :: (Element (IO a) -> Element (IO a)) -> IO a -> IO a #
MonoFunctor (Identity a) # |
Methods omap :: (Element (Identity a) -> Element (Identity a)) -> Identity a -> Identity a #
MonoFunctor (Option a) # |
Methods omap :: (Element (Option a) -> Element (Option a)) -> Option a -> Option a #
MonoFunctor (NonEmpty a) # |
Methods omap :: (Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> NonEmpty a #
MonoFunctor (ZipList a) # |
Methods omap :: (Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> ZipList a #
MonoFunctor (Tree a) # |
Methods omap :: (Element (Tree a) -> Element (Tree a)) -> Tree a -> Tree a #
MonoFunctor (Seq a) # |
Methods omap :: (Element (Seq a) -> Element (Seq a)) -> Seq a -> Seq a #
MonoFunctor (ViewL a) # |
Methods omap :: (Element (ViewL a) -> Element (ViewL a)) -> ViewL a -> ViewL a #
MonoFunctor (ViewR a) # |
Methods omap :: (Element (ViewR a) -> Element (ViewR a)) -> ViewR a -> ViewR a #
MonoFunctor (IntMap a) # |
Methods omap :: (Element (IntMap a) -> Element (IntMap a)) -> IntMap a -> IntMap a #
MonoFunctor (Vector a) # |
Methods omap :: (Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a #
Unbox a => MonoFunctor (Vector a) # |
Methods omap :: (Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a #
Storable a => MonoFunctor (Vector a) # |
Methods omap :: (Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a #
MonoFunctor mono => MonoFunctor (NonNull mono) # |
Methods omap :: (Element (NonNull mono) -> Element (NonNull mono)) -> NonNull mono -> NonNull mono #
MonoFunctor (r -> a) # |
Methods omap :: (Element (r -> a) -> Element (r -> a)) -> (r -> a) -> r -> a #
MonoFunctor (Either a b) # |
Methods omap :: (Element (Either a b) -> Element (Either a b)) -> Either a b -> Either a b #
MonoFunctor (a, b) # |
Methods omap :: (Element (a, b) -> Element (a, b)) -> (a, b) -> (a, b) #
MonoFunctor (Arg a b) # |
Methods omap :: (Element (Arg a b) -> Element (Arg a b)) -> Arg a b -> Arg a b #
Monad m => MonoFunctor (WrappedMonad m a) # |
Methods omap :: (Element (WrappedMonad m a) -> Element (WrappedMonad m a)) -> WrappedMonad m a -> WrappedMonad m a #
MonoFunctor (Map k v) # |
Methods omap :: (Element (Map k v) -> Element (Map k v)) -> Map k v -> Map k v #
Functor m => MonoFunctor (MaybeT m a) # |
Methods omap :: (Element (MaybeT m a) -> Element (MaybeT m a)) -> MaybeT m a -> MaybeT m a #
Functor m => MonoFunctor (ListT m a) # |
Methods omap :: (Element (ListT m a) -> Element (ListT m a)) -> ListT m a -> ListT m a #
MonoFunctor (HashMap k v) # |
Methods omap :: (Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> HashMap k v #
Arrow a => MonoFunctor (WrappedArrow a b c) # |
Methods omap :: (Element (WrappedArrow a b c) -> Element (WrappedArrow a b c)) -> WrappedArrow a b c -> WrappedArrow a b c #
MonoFunctor (Const * m a) # |
Methods omap :: (Element (Const * m a) -> Element (Const * m a)) -> Const * m a -> Const * m a #
Functor m => MonoFunctor (WriterT w m a) # |
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) # |
Methods omap :: (Element (WriterT w m a) -> Element (WriterT w m a)) -> WriterT w m a -> WriterT w m a #
Functor m => MonoFunctor (StateT s m a) # |
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) # |
Methods omap :: (Element (StateT s m a) -> Element (StateT s m a)) -> StateT s m a -> StateT s m a #
Functor m => MonoFunctor (IdentityT * m a) # |
Methods omap :: (Element (IdentityT * m a) -> Element (IdentityT * m a)) -> IdentityT * m a -> IdentityT * m a #
(Functor f, Functor g) => MonoFunctor (Product * f g a) # |
Methods omap :: (Element (Product * f g a) -> Element (Product * f g a)) -> Product * f g a -> Product * f g a #
Functor m => MonoFunctor (ReaderT * r m a) # |
Methods omap :: (Element (ReaderT * r m a) -> Element (ReaderT * r m a)) -> ReaderT * r m a -> ReaderT * r m a #
Functor m => MonoFunctor (ContT * r m a) # |
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) # |
Methods omap :: (Element (Compose * * f g a) -> Element (Compose * * f g a)) -> Compose * * f g a -> Compose * * f g a #
Functor m => MonoFunctor (RWST r w s m a) # |
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) # |
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.

Methods

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

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

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

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

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

Right-associative fold of a monomorphic container.

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

Right-associative fold of a monomorphic container.

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

Strict left-associative fold of a monomorphic container.

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

Strict left-associative fold of a monomorphic container.

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 `ofoldr1Ex` from Data.NonNull for a total version of this function.

ofoldr1Ex :: (t a ~ mono, a ~ Element (t a), Foldable t) => (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 `ofoldr1Ex` from Data.NonNull for a total version of this function.

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 `ofoldl1Ex'` from Data.NonNull for a total version of this function.

ofoldl1Ex' :: (t a ~ mono, a ~ Element (t a), Foldable t) => (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 `ofoldl1Ex'` from Data.NonNull for a total version of this function.

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 'Data.NonNull.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.

Instances

MonoFoldable ByteString # |
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 #
MonoFoldable ByteString # |
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 #
MonoFoldable IntSet # |
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 #
MonoFoldable Text # |
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 #
MonoFoldable Text # |
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 #
MonoFoldable [a] # |
Methods ofoldMap :: Monoid m => (Element [a] -> m) -> [a] -> m # ofoldr :: (Element [a] -> b -> b) -> b -> [a] -> b # ofoldl' :: (a -> Element [a] -> a) -> a -> [a] -> a # 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 => (a -> Element [a] -> m a) -> a -> [a] -> m a # 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] #
MonoFoldable (Maybe a) # |
Methods ofoldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m # ofoldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b # ofoldl' :: (a -> Element (Maybe a) -> a) -> a -> Maybe a -> a # 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 => (a -> Element (Maybe a) -> m a) -> a -> Maybe a -> m a # 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) #
MonoFoldable (Identity a) # |
Methods ofoldMap :: Monoid m => (Element (Identity a) -> m) -> Identity a -> m # ofoldr :: (Element (Identity a) -> b -> b) -> b -> Identity a -> b # ofoldl' :: (a -> Element (Identity a) -> a) -> a -> Identity a -> a # 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 => (a -> Element (Identity a) -> m a) -> a -> Identity a -> m a # 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) #
MonoFoldable (Option a) # |
Methods ofoldMap :: Monoid m => (Element (Option a) -> m) -> Option a -> m # ofoldr :: (Element (Option a) -> b -> b) -> b -> Option a -> b # ofoldl' :: (a -> Element (Option a) -> a) -> a -> Option a -> a # otoList :: Option a -> [Element (Option a)] # oall :: (Element (Option a) -> Bool) -> Option a -> Bool # oany :: (Element (Option a) -> Bool) -> Option a -> Bool # onull :: Option a -> Bool # olength :: Option a -> Int # olength64 :: Option a -> Int64 # ocompareLength :: Integral i => Option a -> i -> Ordering # otraverse_ :: Applicative f => (Element (Option a) -> f b) -> Option a -> f () # ofor_ :: Applicative f => Option a -> (Element (Option a) -> f b) -> f () # omapM_ :: Applicative m => (Element (Option a) -> m ()) -> Option a -> m () # oforM_ :: Applicative m => Option a -> (Element (Option a) -> m ()) -> m () # ofoldlM :: Monad m => (a -> Element (Option a) -> m a) -> a -> Option a -> m a # ofoldMap1Ex :: Semigroup m => (Element (Option a) -> m) -> Option a -> m # ofoldr1Ex :: (Element (Option a) -> Element (Option a) -> Element (Option a)) -> Option a -> Element (Option a) # ofoldl1Ex' :: (Element (Option a) -> Element (Option a) -> Element (Option a)) -> Option a -> Element (Option a) # headEx :: Option a -> Element (Option a) # lastEx :: Option a -> Element (Option a) # unsafeHead :: Option a -> Element (Option a) # unsafeLast :: Option a -> Element (Option a) # maximumByEx :: (Element (Option a) -> Element (Option a) -> Ordering) -> Option a -> Element (Option a) # minimumByEx :: (Element (Option a) -> Element (Option a) -> Ordering) -> Option a -> Element (Option a) #
MonoFoldable (NonEmpty a) # |
Methods ofoldMap :: Monoid m => (Element (NonEmpty a) -> m) -> NonEmpty a -> m # ofoldr :: (Element (NonEmpty a) -> b -> b) -> b -> NonEmpty a -> b # ofoldl' :: (a -> Element (NonEmpty a) -> a) -> a -> NonEmpty a -> a # 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 => (a -> Element (NonEmpty a) -> m a) -> a -> NonEmpty a -> m a # 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) #
MonoFoldable (Tree a) # |
Methods ofoldMap :: Monoid m => (Element (Tree a) -> m) -> Tree a -> m # ofoldr :: (Element (Tree a) -> b -> b) -> b -> Tree a -> b # ofoldl' :: (a -> Element (Tree a) -> a) -> a -> Tree a -> a # 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 => (a -> Element (Tree a) -> m a) -> a -> Tree a -> m a # 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) #
MonoFoldable (Seq a) # |
Methods ofoldMap :: Monoid m => (Element (Seq a) -> m) -> Seq a -> m # ofoldr :: (Element (Seq a) -> b -> b) -> b -> Seq a -> b # ofoldl' :: (a -> Element (Seq a) -> a) -> a -> Seq a -> a # 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 => (a -> Element (Seq a) -> m a) -> a -> Seq a -> m a # 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) #
MonoFoldable (ViewL a) # |
Methods ofoldMap :: Monoid m => (Element (ViewL a) -> m) -> ViewL a -> m # ofoldr :: (Element (ViewL a) -> b -> b) -> b -> ViewL a -> b # ofoldl' :: (a -> Element (ViewL a) -> a) -> a -> ViewL a -> a # 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 => (a -> Element (ViewL a) -> m a) -> a -> ViewL a -> m a # 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) #
MonoFoldable (ViewR a) # |
Methods ofoldMap :: Monoid m => (Element (ViewR a) -> m) -> ViewR a -> m # ofoldr :: (Element (ViewR a) -> b -> b) -> b -> ViewR a -> b # ofoldl' :: (a -> Element (ViewR a) -> a) -> a -> ViewR a -> a # 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 => (a -> Element (ViewR a) -> m a) -> a -> ViewR a -> m a # 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) #
MonoFoldable (IntMap a) # |
Methods ofoldMap :: Monoid m => (Element (IntMap a) -> m) -> IntMap a -> m # ofoldr :: (Element (IntMap a) -> b -> b) -> b -> IntMap a -> b # ofoldl' :: (a -> Element (IntMap a) -> a) -> a -> IntMap a -> a # 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 => (a -> Element (IntMap a) -> m a) -> a -> IntMap a -> m a # 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) #
MonoFoldable (Set e) # |
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) #
MonoFoldable (HashSet e) # |
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) #
MonoFoldable (Vector a) # |
Methods ofoldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m # ofoldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b # ofoldl' :: (a -> Element (Vector a) -> a) -> a -> Vector a -> a # 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 => (a -> Element (Vector a) -> m a) -> a -> Vector a -> m a # 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) #
Unbox a => MonoFoldable (Vector a) # |
Methods ofoldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m # ofoldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b # ofoldl' :: (a -> Element (Vector a) -> a) -> a -> Vector a -> a # 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 => (a -> Element (Vector a) -> m a) -> a -> Vector a -> m a # 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) #
Storable a => MonoFoldable (Vector a) # |
Methods ofoldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m # ofoldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b # ofoldl' :: (a -> Element (Vector a) -> a) -> a -> Vector a -> a # 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 => (a -> Element (Vector a) -> m a) -> a -> Vector a -> m a # 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) #
MonoFoldable mono => MonoFoldable (NonNull mono) # |
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) #
MonoFoldable (Either a b) # |
Methods ofoldMap :: Monoid m => (Element (Either a b) -> m) -> Either a b -> m # ofoldr :: (Element (Either a b) -> b -> b) -> b -> Either a b -> b # ofoldl' :: (a -> Element (Either a b) -> a) -> a -> Either a b -> a # 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 b) -> Either a b -> f () # ofor_ :: Applicative f => Either a b -> (Element (Either a b) -> f b) -> 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 => (a -> Element (Either a b) -> m a) -> a -> Either a b -> m a # 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) #
MonoFoldable (a, b) # |
Methods ofoldMap :: Monoid m => (Element (a, b) -> m) -> (a, b) -> m # ofoldr :: (Element (a, b) -> b -> b) -> b -> (a, b) -> b # ofoldl' :: (a -> Element (a, b) -> a) -> a -> (a, b) -> a # 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 b) -> (a, b) -> f () # ofor_ :: Applicative f => (a, b) -> (Element (a, b) -> f b) -> f () # omapM_ :: Applicative m => (Element (a, b) -> m ()) -> (a, b) -> m () # oforM_ :: Applicative m => (a, b) -> (Element (a, b) -> m ()) -> m () # ofoldlM :: Monad m => (a -> Element (a, b) -> m a) -> a -> (a, b) -> m a # 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) #
MonoFoldable (Map k v) # |
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) #
Foldable f => MonoFoldable (MaybeT f a) # |
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' :: (a -> Element (MaybeT f a) -> a) -> a -> MaybeT f a -> a # 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 f => (Element (MaybeT f a) -> f b) -> MaybeT f a -> f () # ofor_ :: Applicative f => MaybeT f a -> (Element (MaybeT f a) -> f b) -> f () # 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 => (a -> Element (MaybeT f a) -> m a) -> a -> MaybeT f a -> m a # 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) #
Foldable f => MonoFoldable (ListT f a) # |
Methods ofoldMap :: Monoid m => (Element (ListT f a) -> m) -> ListT f a -> m # ofoldr :: (Element (ListT f a) -> b -> b) -> b -> ListT f a -> b # ofoldl' :: (a -> Element (ListT f a) -> a) -> a -> ListT f a -> a # otoList :: ListT f a -> [Element (ListT f a)] # oall :: (Element (ListT f a) -> Bool) -> ListT f a -> Bool # oany :: (Element (ListT f a) -> Bool) -> ListT f a -> Bool # onull :: ListT f a -> Bool # olength :: ListT f a -> Int # olength64 :: ListT f a -> Int64 # ocompareLength :: Integral i => ListT f a -> i -> Ordering # otraverse_ :: Applicative f => (Element (ListT f a) -> f b) -> ListT f a -> f () # ofor_ :: Applicative f => ListT f a -> (Element (ListT f a) -> f b) -> f () # omapM_ :: Applicative m => (Element (ListT f a) -> m ()) -> ListT f a -> m () # oforM_ :: Applicative m => ListT f a -> (Element (ListT f a) -> m ()) -> m () # ofoldlM :: Monad m => (a -> Element (ListT f a) -> m a) -> a -> ListT f a -> m a # ofoldMap1Ex :: Semigroup m => (Element (ListT f a) -> m) -> ListT f a -> m # ofoldr1Ex :: (Element (ListT f a) -> Element (ListT f a) -> Element (ListT f a)) -> ListT f a -> Element (ListT f a) # ofoldl1Ex' :: (Element (ListT f a) -> Element (ListT f a) -> Element (ListT f a)) -> ListT f a -> Element (ListT f a) # headEx :: ListT f a -> Element (ListT f a) # lastEx :: ListT f a -> Element (ListT f a) # unsafeHead :: ListT f a -> Element (ListT f a) # unsafeLast :: ListT f a -> Element (ListT f a) # maximumByEx :: (Element (ListT f a) -> Element (ListT f a) -> Ordering) -> ListT f a -> Element (ListT f a) # minimumByEx :: (Element (ListT f a) -> Element (ListT f a) -> Ordering) -> ListT f a -> Element (ListT f a) #
MonoFoldable (HashMap k v) # |
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) #
MonoFoldable (Const * m a) # |
Methods ofoldMap :: Monoid m => (Element (Const * m a) -> m) -> Const * m a -> m # ofoldr :: (Element (Const * m a) -> b -> b) -> b -> Const * m a -> b # ofoldl' :: (a -> Element (Const * m a) -> a) -> a -> Const * m a -> a # 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 m => (Element (Const * m a) -> m ()) -> Const * m a -> m () # oforM_ :: Applicative m => Const * m a -> (Element (Const * m a) -> m ()) -> m () # ofoldlM :: Monad m => (a -> Element (Const * m a) -> m a) -> a -> Const * m a -> m a # ofoldMap1Ex :: Semigroup m => (Element (Const * m a) -> m) -> Const * m a -> m # 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) #
Foldable f => MonoFoldable (WriterT w f a) # |
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' :: (a -> Element (WriterT w f a) -> a) -> a -> WriterT w f a -> a # 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 f => (Element (WriterT w f a) -> f b) -> WriterT w f a -> f () # ofor_ :: Applicative f => WriterT w f a -> (Element (WriterT w f a) -> f b) -> f () # 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 => (a -> Element (WriterT w f a) -> m a) -> a -> WriterT w f a -> m a # 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) #
Foldable f => MonoFoldable (WriterT w f a) # |
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' :: (a -> Element (WriterT w f a) -> a) -> a -> WriterT w f a -> a # 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 f => (Element (WriterT w f a) -> f b) -> WriterT w f a -> f () # ofor_ :: Applicative f => WriterT w f a -> (Element (WriterT w f a) -> f b) -> f () # 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 => (a -> Element (WriterT w f a) -> m a) -> a -> WriterT w f a -> m a # 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) #
Foldable f => MonoFoldable (IdentityT * f a) # |
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' :: (a -> Element (IdentityT * f a) -> a) -> a -> IdentityT * f a -> a # 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 f => (Element (IdentityT * f a) -> f b) -> IdentityT * f a -> f () # ofor_ :: Applicative f => IdentityT * f a -> (Element (IdentityT * f a) -> f b) -> f () # 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 => (a -> Element (IdentityT * f a) -> m a) -> a -> IdentityT * f a -> m a # 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) #
(Foldable f, Foldable g) => MonoFoldable (Product * f g a) # |
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' :: (a -> Element (Product * f g a) -> a) -> a -> Product * f g a -> a # 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 f => (Element (Product * f g a) -> f b) -> Product * f g a -> f () # ofor_ :: Applicative f => Product * f g a -> (Element (Product * f g a) -> f b) -> f () # 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 => (a -> Element (Product * f g a) -> m a) -> a -> Product * f g a -> m a # 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) #
(Foldable f, Foldable g) => MonoFoldable (Compose * * f g a) # |
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' :: (a -> Element (Compose * * f g a) -> a) -> a -> Compose * * f g a -> a # 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 f => (Element (Compose * * f g a) -> f b) -> Compose * * f g a -> f () # ofor_ :: Applicative f => Compose * * f g a -> (Element (Compose * * f g a) -> f b) -> f () # 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 => (a -> Element (Compose * * f g a) -> m a) -> a -> Compose * * f g a -> m a # 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) #

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

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

Checks if the monomorphic container includes the supplied element.

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

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

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.

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.

otraverse :: (Traversable t, mono ~ t a, a ~ Element mono, 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.

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

MonoTraversable ByteString # |
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 # |
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 # |
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 # |
Methods otraverse :: Applicative f => (Element Text -> f (Element Text)) -> Text -> f Text # omapM :: Applicative m => (Element Text -> m (Element Text)) -> Text -> m Text #
MonoTraversable [a] # |
Methods otraverse :: Applicative f => (Element [a] -> f (Element [a])) -> [a] -> f [a] # omapM :: Applicative m => (Element [a] -> m (Element [a])) -> [a] -> m [a] #
MonoTraversable (Maybe a) # |
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 (Identity a) # |
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 (Option a) # |
Methods otraverse :: Applicative f => (Element (Option a) -> f (Element (Option a))) -> Option a -> f (Option a) # omapM :: Applicative m => (Element (Option a) -> m (Element (Option a))) -> Option a -> m (Option a) #
MonoTraversable (NonEmpty a) # |
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 (Tree a) # |
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 (Seq a) # |
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) # |
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) # |
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 (IntMap a) # |
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 (Vector a) # |
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) # |
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) # |
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 mono => MonoTraversable (NonNull mono) # |
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 (Either a b) # |
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 (a, b) # |
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 (Map k v) # |
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) # |
Methods otraverse :: Applicative f => (Element (MaybeT f a) -> f (Element (MaybeT f a))) -> MaybeT f a -> f (MaybeT f a) # omapM :: Applicative m => (Element (MaybeT f a) -> m (Element (MaybeT f a))) -> MaybeT f a -> m (MaybeT f a) #
Traversable f => MonoTraversable (ListT f a) # |
Methods otraverse :: Applicative f => (Element (ListT f a) -> f (Element (ListT f a))) -> ListT f a -> f (ListT f a) # omapM :: Applicative m => (Element (ListT f a) -> m (Element (ListT f a))) -> ListT f a -> m (ListT f a) #
MonoTraversable (HashMap k v) # |
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 (Const * m a) # |
Methods otraverse :: Applicative f => (Element (Const * m a) -> f (Element (Const * m a))) -> Const * m a -> f (Const * m a) # omapM :: Applicative m => (Element (Const * m a) -> m (Element (Const * m a))) -> Const * m a -> m (Const * m a) #
Traversable f => MonoTraversable (WriterT w f a) # |
Methods otraverse :: Applicative f => (Element (WriterT w f a) -> f (Element (WriterT w f a))) -> WriterT w f a -> f (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) # |
Methods otraverse :: Applicative f => (Element (WriterT w f a) -> f (Element (WriterT w f a))) -> WriterT w f a -> f (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 (IdentityT * f a) # |
Methods otraverse :: Applicative f => (Element (IdentityT * f a) -> f (Element (IdentityT * f a))) -> IdentityT * f a -> f (IdentityT * f a) # omapM :: Applicative m => (Element (IdentityT * f a) -> m (Element (IdentityT * f a))) -> IdentityT * f a -> m (IdentityT * f a) #
(Traversable f, Traversable g) => MonoTraversable (Product * f g a) # |
Methods otraverse :: Applicative f => (Element (Product * f g a) -> f (Element (Product * f g a))) -> Product * f g a -> f (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 (Compose * * f g a) # |
Methods otraverse :: Applicative f => (Element (Compose * * f g a) -> f (Element (Compose * * f g a))) -> Compose * * f g a -> f (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) #

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

Methods

opoint :: Element mono -> mono #

Lift an element into a monomorphic container.

`opoint` is the same as `pure` for an `Applicative`

opoint :: (Applicative f, f a ~ mono, Element (f a) ~ a) => Element mono -> mono #

Lift an element into a monomorphic container.

`opoint` is the same as `pure` for an `Applicative`

Instances

MonoPointed ByteString # |
Methods opoint :: Element ByteString -> ByteString #
MonoPointed ByteString # |
Methods opoint :: Element ByteString -> ByteString #
MonoPointed IntSet # |
Methods opoint :: Element IntSet -> IntSet #
MonoPointed Text # |
Methods opoint :: Element Text -> Text #
MonoPointed Text # |
Methods opoint :: Element Text -> Text #
MonoPointed [a] # |
Methods opoint :: Element [a] -> [a] #
MonoPointed (Maybe a) # |
Methods opoint :: Element (Maybe a) -> Maybe a #
MonoPointed (IO a) # |
Methods opoint :: Element (IO a) -> IO a #
MonoPointed (Identity a) # |
Methods opoint :: Element (Identity a) -> Identity a #
MonoPointed (Option a) # |
Methods opoint :: Element (Option a) -> Option a #
MonoPointed (NonEmpty a) # |
Methods opoint :: Element (NonEmpty a) -> NonEmpty a #
MonoPointed (ZipList a) # |
Methods opoint :: Element (ZipList a) -> ZipList a #
MonoPointed (Tree a) # |
Methods opoint :: Element (Tree a) -> Tree a #
MonoPointed (Seq a) # |
Methods opoint :: Element (Seq a) -> Seq a #
MonoPointed (ViewL a) # |
Methods opoint :: Element (ViewL a) -> ViewL a #
MonoPointed (ViewR a) # |
Methods opoint :: Element (ViewR a) -> ViewR a #
MonoPointed (Set a) # |
Methods opoint :: Element (Set a) -> Set a #
Hashable a => MonoPointed (HashSet a) # |
Methods opoint :: Element (HashSet a) -> HashSet a #
MonoPointed (Vector a) # |
Methods opoint :: Element (Vector a) -> Vector a #
Unbox a => MonoPointed (Vector a) # |
Methods opoint :: Element (Vector a) -> Vector a #
Storable a => MonoPointed (Vector a) # |
Methods opoint :: Element (Vector a) -> Vector a #
MonoPointed mono => MonoPointed (NonNull mono) # |
Methods opoint :: Element (NonNull mono) -> NonNull mono #
MonoPointed (r -> a) # |
Methods opoint :: Element (r -> a) -> r -> a #
MonoPointed (Either a b) # |
Methods opoint :: Element (Either a b) -> Either a b #
Monoid a => MonoPointed (a, b) # |
Methods opoint :: Element (a, b) -> (a, b) #
Monad m => MonoPointed (WrappedMonad m a) # |
Methods opoint :: Element (WrappedMonad m a) -> WrappedMonad m a #
Applicative f => MonoPointed (MaybeT f a) # |
Methods opoint :: Element (MaybeT f a) -> MaybeT f a #
Applicative m => MonoPointed (ListT m a) # |
Methods opoint :: Element (ListT m a) -> ListT m a #
Arrow a => MonoPointed (WrappedArrow a b c) # |
Methods opoint :: Element (WrappedArrow a b c) -> WrappedArrow a b c #
Monoid m => MonoPointed (Const * m a) # |
Methods opoint :: Element (Const * m a) -> Const * m a #
(Monoid w, Applicative m) => MonoPointed (WriterT w m a) # |
Methods opoint :: Element (WriterT w m a) -> WriterT w m a #
(Monoid w, Applicative m) => MonoPointed (WriterT w m a) # |
Methods opoint :: Element (WriterT w m a) -> WriterT w m a #
Applicative m => MonoPointed (StateT s m a) # |
Methods opoint :: Element (StateT s m a) -> StateT s m a #
Applicative m => MonoPointed (StateT s m a) # |
Methods opoint :: Element (StateT s m a) -> StateT s m a #
Applicative m => MonoPointed (IdentityT * m a) # |
Methods opoint :: Element (IdentityT * m a) -> IdentityT * m a #
(Applicative f, Applicative g) => MonoPointed (Product * f g a) # |
Methods opoint :: Element (Product * f g a) -> Product * f g a #
Applicative m => MonoPointed (ReaderT * r m a) # |
Methods opoint :: Element (ReaderT * r m a) -> ReaderT * r m a #
MonoPointed (ContT * r m a) # |
Methods opoint :: Element (ContT * r m a) -> ContT * r m a #
(Applicative f, Applicative g) => MonoPointed (Compose * * f g a) # |
Methods opoint :: Element (Compose * * f g a) -> Compose * * f g a #
(Monoid w, Applicative m) => MonoPointed (RWST r w s m a) # |
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) # |
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`.

Minimal complete definition

oextract, oextend

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

MonoComonad (ViewL a) # |
Methods oextract :: ViewL a -> Element (ViewL a) # oextend :: (ViewL a -> Element (ViewL a)) -> ViewL a -> ViewL a #
MonoComonad (ViewR a) # |
Methods oextract :: ViewR a -> Element (ViewR a) # oextend :: (ViewR a -> Element (ViewR a)) -> ViewR a -> ViewR a #
IsSequence mono => MonoComonad (NonNull mono) # |
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

GrowingAppend ByteString # |
GrowingAppend ByteString # |
GrowingAppend IntSet # |
GrowingAppend Text # |
GrowingAppend Text # |
GrowingAppend [a] # |
GrowingAppend (NonEmpty a) # |
GrowingAppend (Seq a) # |
GrowingAppend (IntMap v) # |
Ord v => GrowingAppend (Set v) # |
(Eq v, Hashable v) => GrowingAppend (HashSet v) # |
GrowingAppend (Vector a) # |
Unbox a => GrowingAppend (Vector a) # |
Storable a => GrowingAppend (Vector a) # |
GrowingAppend mono => GrowingAppend (NonNull mono) # |
Ord k => GrowingAppend (Map k v) # |
(Eq k, Hashable k) => GrowingAppend (HashMap k v) # |

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