Data.MonoTraversable

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

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

type Element (IntMap 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 (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 (IntMap a)

Methods

omap :: (Element (IntMap a) -> Element (IntMap a)) -> IntMap a -> IntMap 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 (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

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

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)

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)

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

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)

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

Storable a => MonoPointed (Vector a)

Methods

opoint :: Element (Vector a) -> Vector a

Unbox 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 (IntMap v)

GrowingAppend (Seq a)

Ord v => GrowingAppend (Set v)

(Eq v, Hashable v) => GrowingAppend (HashSet v)

GrowingAppend (Vector a)

Storable a => GrowingAppend (Vector a)

Unbox 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