Universum.Container

This module exports all container-related stuff.

Documentation

class One x where

Type class for types that can be created from one element. singleton is lone name for this function. Also constructions of different type differ: :[] for lists, two arguments for Maps. Also some data types are monomorphic.

>>> one True :: [Bool]
[True]
>>> one 'a' :: Text
"a"
>>> one (3, "hello") :: HashMap Int String
fromList [(3,"hello")]

Associated Types

type OneItem x

Methods

one :: OneItem x -> x

Create a list, map, Text, etc from a single element.

Instances

One ByteString

Defined in Universum.Container.Class

Associated Types

type OneItem ByteString

Methods

one :: OneItem ByteString -> ByteString

One ByteString

Defined in Universum.Container.Class

Associated Types

type OneItem ByteString

Methods

one :: OneItem ByteString -> ByteString

One IntSet

Defined in Universum.Container.Class

Associated Types

type OneItem IntSet

Methods

one :: OneItem IntSet -> IntSet

One Text

Defined in Universum.Container.Class

Associated Types

type OneItem Text

Methods

one :: OneItem Text -> Text

One Text

Defined in Universum.Container.Class

Associated Types

type OneItem Text

Methods

one :: OneItem Text -> Text

One [a]

Defined in Universum.Container.Class

Associated Types

type OneItem [a]

Methods

one :: OneItem [a] -> [a]

One (NonEmpty a)

Defined in Universum.Container.Class

Associated Types

type OneItem (NonEmpty a)

Methods

one :: OneItem (NonEmpty a) -> NonEmpty a

One (IntMap v)

Defined in Universum.Container.Class

Associated Types

type OneItem (IntMap v)

Methods

one :: OneItem (IntMap v) -> IntMap v

One (Seq a)

Defined in Universum.Container.Class

Associated Types

type OneItem (Seq a)

Methods

one :: OneItem (Seq a) -> Seq a

One (Set v)

Defined in Universum.Container.Class

Associated Types

type OneItem (Set v)

Methods

one :: OneItem (Set v) -> Set v

Hashable v => One (HashSet v)

Defined in Universum.Container.Class

Associated Types

type OneItem (HashSet v)

Methods

one :: OneItem (HashSet v) -> HashSet v

Unbox a => One (Vector a)

Defined in Universum.Container.Class

Associated Types

type OneItem (Vector a)

Methods

one :: OneItem (Vector a) -> Vector a

Storable a => One (Vector a)

Defined in Universum.Container.Class

Associated Types

type OneItem (Vector a)

Methods

one :: OneItem (Vector a) -> Vector a

Prim a => One (Vector a)

Defined in Universum.Container.Class

Associated Types

type OneItem (Vector a)

Methods

one :: OneItem (Vector a) -> Vector a

One (Vector a)

Defined in Universum.Container.Class

Associated Types

type OneItem (Vector a)

Methods

one :: OneItem (Vector a) -> Vector a

One (Map k v)

Defined in Universum.Container.Class

Associated Types

type OneItem (Map k v)

Methods

one :: OneItem (Map k v) -> Map k v

Hashable k => One (HashMap k v)

Defined in Universum.Container.Class

Associated Types

type OneItem (HashMap k v)

Methods

one :: OneItem (HashMap k v) -> HashMap k v

class Container t where

Very similar to Foldable but also allows instances for monomorphic types like Text but forbids instances for Maybe and similar. This class is used as a replacement for Foldable type class. It solves the following problems:

1. length, foldr and other functions work on more types for which it makes sense.
2. You can't accidentally use length on polymorphic Foldable (like list), replace list with Maybe and then debug error for two days.
3. More efficient implementaions of functions for polymorphic types (like elem for Set).

The drawbacks:

1. Type signatures of polymorphic functions look more scary.
2. Orphan instances are involved if you want to use foldr (and similar) on types from libraries.

Minimal complete definition

Nothing

Associated Types

type Element t :: Type

Type of element for some container. Implemented as an asscociated type family because some containers are monomorphic over element type (like Text, IntSet, etc.) so we can't implement nice interface using old higher-kinded types approach. Implementing this as an associated type family instead of top-level family gives you more control over element types.

type Element t = ElementDefault t

Methods

toList :: t -> [Element t]

Convert container to list of elements.

>>> toList @Text "aba"
"aba"
>>> :t toList @Text "aba"
toList @Text "aba" :: [Char]

default toList :: (Foldable f, t ~ f a, Element t ~ a) => t -> [Element t]

null :: t -> Bool

Checks whether container is empty.

>>> null @Text ""
True
>>> null @Text "aba"
False

default null :: (Foldable f, t ~ f a) => t -> Bool

foldr :: (Element t -> b -> b) -> b -> t -> b

default foldr :: (Foldable f, t ~ f a, Element t ~ a) => (Element t -> b -> b) -> b -> t -> b

foldl :: (b -> Element t -> b) -> b -> t -> b

default foldl :: (Foldable f, t ~ f a, Element t ~ a) => (b -> Element t -> b) -> b -> t -> b

foldl' :: (b -> Element t -> b) -> b -> t -> b

default foldl' :: (Foldable f, t ~ f a, Element t ~ a) => (b -> Element t -> b) -> b -> t -> b

length :: t -> Int

default length :: (Foldable f, t ~ f a) => t -> Int

elem :: Eq (Element t) => Element t -> t -> Bool

default elem :: (Foldable f, t ~ f a, Element t ~ a, Eq a) => Element t -> t -> Bool

foldMap :: Monoid m => (Element t -> m) -> t -> m

fold :: Monoid (Element t) => t -> Element t

foldr' :: (Element t -> b -> b) -> b -> t -> b

notElem :: Eq (Element t) => Element t -> t -> Bool

all :: (Element t -> Bool) -> t -> Bool

any :: (Element t -> Bool) -> t -> Bool

and :: Element t ~ Bool => t -> Bool

or :: Element t ~ Bool => t -> Bool

find :: (Element t -> Bool) -> t -> Maybe (Element t)

safeHead :: t -> Maybe (Element t)

safeMaximum :: Ord (Element t) => t -> Maybe (Element t)

default safeMaximum :: (Foldable f, t ~ f a, Element t ~ a, Ord (Element t)) => t -> Maybe (Element t)

safeMinimum :: Ord (Element t) => t -> Maybe (Element t)

default safeMinimum :: (Foldable f, t ~ f a, Element t ~ a, Ord (Element t)) => t -> Maybe (Element t)

safeFoldr1 :: (Element t -> Element t -> Element t) -> t -> Maybe (Element t)

safeFoldl1 :: (Element t -> Element t -> Element t) -> t -> Maybe (Element t)

Instances

Container ByteString

Defined in Universum.Container.Class

Associated Types

type Element ByteString

Methods

toList :: ByteString -> [Element ByteString]

null :: ByteString -> Bool

foldr :: (Element ByteString -> b -> b) -> b -> ByteString -> b

foldl :: (b -> Element ByteString -> b) -> b -> ByteString -> b

foldl' :: (b -> Element ByteString -> b) -> b -> ByteString -> b

length :: ByteString -> Int

elem :: Element ByteString -> ByteString -> Bool

foldMap :: Monoid m => (Element ByteString -> m) -> ByteString -> m

fold :: ByteString -> Element ByteString

foldr' :: (Element ByteString -> b -> b) -> b -> ByteString -> b

notElem :: Element ByteString -> ByteString -> Bool

all :: (Element ByteString -> Bool) -> ByteString -> Bool

any :: (Element ByteString -> Bool) -> ByteString -> Bool

and :: ByteString -> Bool

or :: ByteString -> Bool

find :: (Element ByteString -> Bool) -> ByteString -> Maybe (Element ByteString)

safeHead :: ByteString -> Maybe (Element ByteString)

safeMaximum :: ByteString -> Maybe (Element ByteString)

safeMinimum :: ByteString -> Maybe (Element ByteString)

safeFoldr1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString)

safeFoldl1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString)

Container ByteString

Defined in Universum.Container.Class

Associated Types

type Element ByteString

Methods

toList :: ByteString -> [Element ByteString]

null :: ByteString -> Bool

foldr :: (Element ByteString -> b -> b) -> b -> ByteString -> b

foldl :: (b -> Element ByteString -> b) -> b -> ByteString -> b

foldl' :: (b -> Element ByteString -> b) -> b -> ByteString -> b

length :: ByteString -> Int

elem :: Element ByteString -> ByteString -> Bool

foldMap :: Monoid m => (Element ByteString -> m) -> ByteString -> m

fold :: ByteString -> Element ByteString

foldr' :: (Element ByteString -> b -> b) -> b -> ByteString -> b

notElem :: Element ByteString -> ByteString -> Bool

all :: (Element ByteString -> Bool) -> ByteString -> Bool

any :: (Element ByteString -> Bool) -> ByteString -> Bool

and :: ByteString -> Bool

or :: ByteString -> Bool

find :: (Element ByteString -> Bool) -> ByteString -> Maybe (Element ByteString)

safeHead :: ByteString -> Maybe (Element ByteString)

safeMaximum :: ByteString -> Maybe (Element ByteString)

safeMinimum :: ByteString -> Maybe (Element ByteString)

safeFoldr1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString)

safeFoldl1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Maybe (Element ByteString)

Container IntSet

Defined in Universum.Container.Class

Associated Types

type Element IntSet

Methods

toList :: IntSet -> [Element IntSet]

null :: IntSet -> Bool

foldr :: (Element IntSet -> b -> b) -> b -> IntSet -> b

foldl :: (b -> Element IntSet -> b) -> b -> IntSet -> b

foldl' :: (b -> Element IntSet -> b) -> b -> IntSet -> b

length :: IntSet -> Int

elem :: Element IntSet -> IntSet -> Bool

foldMap :: Monoid m => (Element IntSet -> m) -> IntSet -> m

fold :: IntSet -> Element IntSet

foldr' :: (Element IntSet -> b -> b) -> b -> IntSet -> b

notElem :: Element IntSet -> IntSet -> Bool

all :: (Element IntSet -> Bool) -> IntSet -> Bool

any :: (Element IntSet -> Bool) -> IntSet -> Bool

and :: IntSet -> Bool

or :: IntSet -> Bool

find :: (Element IntSet -> Bool) -> IntSet -> Maybe (Element IntSet)

safeHead :: IntSet -> Maybe (Element IntSet)

safeMaximum :: IntSet -> Maybe (Element IntSet)

safeMinimum :: IntSet -> Maybe (Element IntSet)

safeFoldr1 :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Maybe (Element IntSet)

safeFoldl1 :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Maybe (Element IntSet)

Container Text

Defined in Universum.Container.Class

Associated Types

type Element Text

Methods

toList :: Text -> [Element Text]

null :: Text -> Bool

foldr :: (Element Text -> b -> b) -> b -> Text -> b

foldl :: (b -> Element Text -> b) -> b -> Text -> b

foldl' :: (b -> Element Text -> b) -> b -> Text -> b

length :: Text -> Int

elem :: Element Text -> Text -> Bool

foldMap :: Monoid m => (Element Text -> m) -> Text -> m

fold :: Text -> Element Text

foldr' :: (Element Text -> b -> b) -> b -> Text -> b

notElem :: Element Text -> Text -> Bool

all :: (Element Text -> Bool) -> Text -> Bool

any :: (Element Text -> Bool) -> Text -> Bool

and :: Text -> Bool

or :: Text -> Bool

find :: (Element Text -> Bool) -> Text -> Maybe (Element Text)

safeHead :: Text -> Maybe (Element Text)

safeMaximum :: Text -> Maybe (Element Text)

safeMinimum :: Text -> Maybe (Element Text)

safeFoldr1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text)

safeFoldl1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text)

Container Text

Defined in Universum.Container.Class

Associated Types

type Element Text

Methods

toList :: Text -> [Element Text]

null :: Text -> Bool

foldr :: (Element Text -> b -> b) -> b -> Text -> b

foldl :: (b -> Element Text -> b) -> b -> Text -> b

foldl' :: (b -> Element Text -> b) -> b -> Text -> b

length :: Text -> Int

elem :: Element Text -> Text -> Bool

foldMap :: Monoid m => (Element Text -> m) -> Text -> m

fold :: Text -> Element Text

foldr' :: (Element Text -> b -> b) -> b -> Text -> b

notElem :: Element Text -> Text -> Bool

all :: (Element Text -> Bool) -> Text -> Bool

any :: (Element Text -> Bool) -> Text -> Bool

and :: Text -> Bool

or :: Text -> Bool

find :: (Element Text -> Bool) -> Text -> Maybe (Element Text)

safeHead :: Text -> Maybe (Element Text)

safeMaximum :: Text -> Maybe (Element Text)

safeMinimum :: Text -> Maybe (Element Text)

safeFoldr1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text)

safeFoldl1 :: (Element Text -> Element Text -> Element Text) -> Text -> Maybe (Element Text)

Container [a]

Defined in Universum.Container.Class

Associated Types

type Element [a]

Methods

toList :: [a] -> [Element [a]]

null :: [a] -> Bool

foldr :: (Element [a] -> b -> b) -> b -> [a] -> b

foldl :: (b -> Element [a] -> b) -> b -> [a] -> b

foldl' :: (b -> Element [a] -> b) -> b -> [a] -> b

length :: [a] -> Int

elem :: Element [a] -> [a] -> Bool

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

fold :: [a] -> Element [a]

foldr' :: (Element [a] -> b -> b) -> b -> [a] -> b

notElem :: Element [a] -> [a] -> Bool

all :: (Element [a] -> Bool) -> [a] -> Bool

any :: (Element [a] -> Bool) -> [a] -> Bool

and :: [a] -> Bool

or :: [a] -> Bool

find :: (Element [a] -> Bool) -> [a] -> Maybe (Element [a])

safeHead :: [a] -> Maybe (Element [a])

safeMaximum :: [a] -> Maybe (Element [a])

safeMinimum :: [a] -> Maybe (Element [a])

safeFoldr1 :: (Element [a] -> Element [a] -> Element [a]) -> [a] -> Maybe (Element [a])

safeFoldl1 :: (Element [a] -> Element [a] -> Element [a]) -> [a] -> Maybe (Element [a])

(TypeError (DisallowInstance "Maybe") :: Constraint) => Container (Maybe a)

Defined in Universum.Container.Class

Associated Types

type Element (Maybe a)

Methods

toList :: Maybe a -> [Element (Maybe a)]

null :: Maybe a -> Bool

foldr :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b

foldl :: (b -> Element (Maybe a) -> b) -> b -> Maybe a -> b

foldl' :: (b -> Element (Maybe a) -> b) -> b -> Maybe a -> b

length :: Maybe a -> Int

elem :: Element (Maybe a) -> Maybe a -> Bool

foldMap :: Monoid m => (Element (Maybe a) -> m) -> Maybe a -> m

fold :: Maybe a -> Element (Maybe a)

foldr' :: (Element (Maybe a) -> b -> b) -> b -> Maybe a -> b

notElem :: Element (Maybe a) -> Maybe a -> Bool

all :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool

any :: (Element (Maybe a) -> Bool) -> Maybe a -> Bool

and :: Maybe a -> Bool

or :: Maybe a -> Bool

find :: (Element (Maybe a) -> Bool) -> Maybe a -> Maybe (Element (Maybe a))

safeHead :: Maybe a -> Maybe (Element (Maybe a))

safeMaximum :: Maybe a -> Maybe (Element (Maybe a))

safeMinimum :: Maybe a -> Maybe (Element (Maybe a))

safeFoldr1 :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe (Element (Maybe a))

safeFoldl1 :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe (Element (Maybe a))

Container (ZipList a)

Defined in Universum.Container.Class

Associated Types

type Element (ZipList a)

Methods

toList :: ZipList a -> [Element (ZipList a)]

null :: ZipList a -> Bool

foldr :: (Element (ZipList a) -> b -> b) -> b -> ZipList a -> b

foldl :: (b -> Element (ZipList a) -> b) -> b -> ZipList a -> b

foldl' :: (b -> Element (ZipList a) -> b) -> b -> ZipList a -> b

length :: ZipList a -> Int

elem :: Element (ZipList a) -> ZipList a -> Bool

foldMap :: Monoid m => (Element (ZipList a) -> m) -> ZipList a -> m

fold :: ZipList a -> Element (ZipList a)

foldr' :: (Element (ZipList a) -> b -> b) -> b -> ZipList a -> b

notElem :: Element (ZipList a) -> ZipList a -> Bool

all :: (Element (ZipList a) -> Bool) -> ZipList a -> Bool

any :: (Element (ZipList a) -> Bool) -> ZipList a -> Bool

and :: ZipList a -> Bool

or :: ZipList a -> Bool

find :: (Element (ZipList a) -> Bool) -> ZipList a -> Maybe (Element (ZipList a))

safeHead :: ZipList a -> Maybe (Element (ZipList a))

safeMaximum :: ZipList a -> Maybe (Element (ZipList a))

safeMinimum :: ZipList a -> Maybe (Element (ZipList a))

safeFoldr1 :: (Element (ZipList a) -> Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> Maybe (Element (ZipList a))

safeFoldl1 :: (Element (ZipList a) -> Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> Maybe (Element (ZipList a))

(TypeError (DisallowInstance "Identity") :: Constraint) => Container (Identity a)

Defined in Universum.Container.Class

Associated Types

type Element (Identity a)

Methods

toList :: Identity a -> [Element (Identity a)]

null :: Identity a -> Bool

foldr :: (Element (Identity a) -> b -> b) -> b -> Identity a -> b

foldl :: (b -> Element (Identity a) -> b) -> b -> Identity a -> b

foldl' :: (b -> Element (Identity a) -> b) -> b -> Identity a -> b

length :: Identity a -> Int

elem :: Element (Identity a) -> Identity a -> Bool

foldMap :: Monoid m => (Element (Identity a) -> m) -> Identity a -> m

fold :: Identity a -> Element (Identity a)

foldr' :: (Element (Identity a) -> b -> b) -> b -> Identity a -> b

notElem :: Element (Identity a) -> Identity a -> Bool

all :: (Element (Identity a) -> Bool) -> Identity a -> Bool

any :: (Element (Identity a) -> Bool) -> Identity a -> Bool

and :: Identity a -> Bool

or :: Identity a -> Bool

find :: (Element (Identity a) -> Bool) -> Identity a -> Maybe (Element (Identity a))

safeHead :: Identity a -> Maybe (Element (Identity a))

safeMaximum :: Identity a -> Maybe (Element (Identity a))

safeMinimum :: Identity a -> Maybe (Element (Identity a))

safeFoldr1 :: (Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Maybe (Element (Identity a))

safeFoldl1 :: (Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Maybe (Element (Identity a))

Container (First a)

Defined in Universum.Container.Class

Associated Types

type Element (First a)

Methods

toList :: First a -> [Element (First a)]

null :: First a -> Bool

foldr :: (Element (First a) -> b -> b) -> b -> First a -> b

foldl :: (b -> Element (First a) -> b) -> b -> First a -> b

foldl' :: (b -> Element (First a) -> b) -> b -> First a -> b

length :: First a -> Int

elem :: Element (First a) -> First a -> Bool

foldMap :: Monoid m => (Element (First a) -> m) -> First a -> m

fold :: First a -> Element (First a)

foldr' :: (Element (First a) -> b -> b) -> b -> First a -> b

notElem :: Element (First a) -> First a -> Bool

all :: (Element (First a) -> Bool) -> First a -> Bool

any :: (Element (First a) -> Bool) -> First a -> Bool

and :: First a -> Bool

or :: First a -> Bool

find :: (Element (First a) -> Bool) -> First a -> Maybe (Element (First a))

safeHead :: First a -> Maybe (Element (First a))

safeMaximum :: First a -> Maybe (Element (First a))

safeMinimum :: First a -> Maybe (Element (First a))

safeFoldr1 :: (Element (First a) -> Element (First a) -> Element (First a)) -> First a -> Maybe (Element (First a))

safeFoldl1 :: (Element (First a) -> Element (First a) -> Element (First a)) -> First a -> Maybe (Element (First a))

Container (Last a)

Defined in Universum.Container.Class

Associated Types

type Element (Last a)

Methods

toList :: Last a -> [Element (Last a)]

null :: Last a -> Bool

foldr :: (Element (Last a) -> b -> b) -> b -> Last a -> b

foldl :: (b -> Element (Last a) -> b) -> b -> Last a -> b

foldl' :: (b -> Element (Last a) -> b) -> b -> Last a -> b

length :: Last a -> Int

elem :: Element (Last a) -> Last a -> Bool

foldMap :: Monoid m => (Element (Last a) -> m) -> Last a -> m

fold :: Last a -> Element (Last a)

foldr' :: (Element (Last a) -> b -> b) -> b -> Last a -> b

notElem :: Element (Last a) -> Last a -> Bool

all :: (Element (Last a) -> Bool) -> Last a -> Bool

any :: (Element (Last a) -> Bool) -> Last a -> Bool

and :: Last a -> Bool

or :: Last a -> Bool

find :: (Element (Last a) -> Bool) -> Last a -> Maybe (Element (Last a))

safeHead :: Last a -> Maybe (Element (Last a))

safeMaximum :: Last a -> Maybe (Element (Last a))

safeMinimum :: Last a -> Maybe (Element (Last a))

safeFoldr1 :: (Element (Last a) -> Element (Last a) -> Element (Last a)) -> Last a -> Maybe (Element (Last a))

safeFoldl1 :: (Element (Last a) -> Element (Last a) -> Element (Last a)) -> Last a -> Maybe (Element (Last a))

Container (Dual a)

Defined in Universum.Container.Class

Associated Types

type Element (Dual a)

Methods

toList :: Dual a -> [Element (Dual a)]

null :: Dual a -> Bool

foldr :: (Element (Dual a) -> b -> b) -> b -> Dual a -> b

foldl :: (b -> Element (Dual a) -> b) -> b -> Dual a -> b

foldl' :: (b -> Element (Dual a) -> b) -> b -> Dual a -> b

length :: Dual a -> Int

elem :: Element (Dual a) -> Dual a -> Bool

foldMap :: Monoid m => (Element (Dual a) -> m) -> Dual a -> m

fold :: Dual a -> Element (Dual a)

foldr' :: (Element (Dual a) -> b -> b) -> b -> Dual a -> b

notElem :: Element (Dual a) -> Dual a -> Bool

all :: (Element (Dual a) -> Bool) -> Dual a -> Bool

any :: (Element (Dual a) -> Bool) -> Dual a -> Bool

and :: Dual a -> Bool

or :: Dual a -> Bool

find :: (Element (Dual a) -> Bool) -> Dual a -> Maybe (Element (Dual a))

safeHead :: Dual a -> Maybe (Element (Dual a))

safeMaximum :: Dual a -> Maybe (Element (Dual a))

safeMinimum :: Dual a -> Maybe (Element (Dual a))

safeFoldr1 :: (Element (Dual a) -> Element (Dual a) -> Element (Dual a)) -> Dual a -> Maybe (Element (Dual a))

safeFoldl1 :: (Element (Dual a) -> Element (Dual a) -> Element (Dual a)) -> Dual a -> Maybe (Element (Dual a))

Container (Sum a)

Defined in Universum.Container.Class

Associated Types

type Element (Sum a)

Methods

toList :: Sum a -> [Element (Sum a)]

null :: Sum a -> Bool

foldr :: (Element (Sum a) -> b -> b) -> b -> Sum a -> b

foldl :: (b -> Element (Sum a) -> b) -> b -> Sum a -> b

foldl' :: (b -> Element (Sum a) -> b) -> b -> Sum a -> b

length :: Sum a -> Int

elem :: Element (Sum a) -> Sum a -> Bool

foldMap :: Monoid m => (Element (Sum a) -> m) -> Sum a -> m

fold :: Sum a -> Element (Sum a)

foldr' :: (Element (Sum a) -> b -> b) -> b -> Sum a -> b

notElem :: Element (Sum a) -> Sum a -> Bool

all :: (Element (Sum a) -> Bool) -> Sum a -> Bool

any :: (Element (Sum a) -> Bool) -> Sum a -> Bool

and :: Sum a -> Bool

or :: Sum a -> Bool

find :: (Element (Sum a) -> Bool) -> Sum a -> Maybe (Element (Sum a))

safeHead :: Sum a -> Maybe (Element (Sum a))

safeMaximum :: Sum a -> Maybe (Element (Sum a))

safeMinimum :: Sum a -> Maybe (Element (Sum a))

safeFoldr1 :: (Element (Sum a) -> Element (Sum a) -> Element (Sum a)) -> Sum a -> Maybe (Element (Sum a))

safeFoldl1 :: (Element (Sum a) -> Element (Sum a) -> Element (Sum a)) -> Sum a -> Maybe (Element (Sum a))

Container (Product a)

Defined in Universum.Container.Class

Associated Types

type Element (Product a)

Methods

toList :: Product a -> [Element (Product a)]

null :: Product a -> Bool

foldr :: (Element (Product a) -> b -> b) -> b -> Product a -> b

foldl :: (b -> Element (Product a) -> b) -> b -> Product a -> b

foldl' :: (b -> Element (Product a) -> b) -> b -> Product a -> b

length :: Product a -> Int

elem :: Element (Product a) -> Product a -> Bool

foldMap :: Monoid m => (Element (Product a) -> m) -> Product a -> m

fold :: Product a -> Element (Product a)

foldr' :: (Element (Product a) -> b -> b) -> b -> Product a -> b

notElem :: Element (Product a) -> Product a -> Bool

all :: (Element (Product a) -> Bool) -> Product a -> Bool

any :: (Element (Product a) -> Bool) -> Product a -> Bool

and :: Product a -> Bool

or :: Product a -> Bool

find :: (Element (Product a) -> Bool) -> Product a -> Maybe (Element (Product a))

safeHead :: Product a -> Maybe (Element (Product a))

safeMaximum :: Product a -> Maybe (Element (Product a))

safeMinimum :: Product a -> Maybe (Element (Product a))

safeFoldr1 :: (Element (Product a) -> Element (Product a) -> Element (Product a)) -> Product a -> Maybe (Element (Product a))

safeFoldl1 :: (Element (Product a) -> Element (Product a) -> Element (Product a)) -> Product a -> Maybe (Element (Product a))

Container (NonEmpty a)

Defined in Universum.Container.Class

Associated Types

type Element (NonEmpty a)

Methods

toList :: NonEmpty a -> [Element (NonEmpty a)]

null :: NonEmpty a -> Bool

foldr :: (Element (NonEmpty a) -> b -> b) -> b -> NonEmpty a -> b

foldl :: (b -> Element (NonEmpty a) -> b) -> b -> NonEmpty a -> b

foldl' :: (b -> Element (NonEmpty a) -> b) -> b -> NonEmpty a -> b

length :: NonEmpty a -> Int

elem :: Element (NonEmpty a) -> NonEmpty a -> Bool

foldMap :: Monoid m => (Element (NonEmpty a) -> m) -> NonEmpty a -> m

fold :: NonEmpty a -> Element (NonEmpty a)

foldr' :: (Element (NonEmpty a) -> b -> b) -> b -> NonEmpty a -> b

notElem :: Element (NonEmpty a) -> NonEmpty a -> Bool

all :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool

any :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Bool

and :: NonEmpty a -> Bool

or :: NonEmpty a -> Bool

find :: (Element (NonEmpty a) -> Bool) -> NonEmpty a -> Maybe (Element (NonEmpty a))

safeHead :: NonEmpty a -> Maybe (Element (NonEmpty a))

safeMaximum :: NonEmpty a -> Maybe (Element (NonEmpty a))

safeMinimum :: NonEmpty a -> Maybe (Element (NonEmpty a))

safeFoldr1 :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Maybe (Element (NonEmpty a))

safeFoldl1 :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> Maybe (Element (NonEmpty a))

Container (IntMap v)

Defined in Universum.Container.Class

Associated Types

type Element (IntMap v)

Methods

toList :: IntMap v -> [Element (IntMap v)]

null :: IntMap v -> Bool

foldr :: (Element (IntMap v) -> b -> b) -> b -> IntMap v -> b

foldl :: (b -> Element (IntMap v) -> b) -> b -> IntMap v -> b

foldl' :: (b -> Element (IntMap v) -> b) -> b -> IntMap v -> b

length :: IntMap v -> Int

elem :: Element (IntMap v) -> IntMap v -> Bool

foldMap :: Monoid m => (Element (IntMap v) -> m) -> IntMap v -> m

fold :: IntMap v -> Element (IntMap v)

foldr' :: (Element (IntMap v) -> b -> b) -> b -> IntMap v -> b

notElem :: Element (IntMap v) -> IntMap v -> Bool

all :: (Element (IntMap v) -> Bool) -> IntMap v -> Bool

any :: (Element (IntMap v) -> Bool) -> IntMap v -> Bool

and :: IntMap v -> Bool

or :: IntMap v -> Bool

find :: (Element (IntMap v) -> Bool) -> IntMap v -> Maybe (Element (IntMap v))

safeHead :: IntMap v -> Maybe (Element (IntMap v))

safeMaximum :: IntMap v -> Maybe (Element (IntMap v))

safeMinimum :: IntMap v -> Maybe (Element (IntMap v))

safeFoldr1 :: (Element (IntMap v) -> Element (IntMap v) -> Element (IntMap v)) -> IntMap v -> Maybe (Element (IntMap v))

safeFoldl1 :: (Element (IntMap v) -> Element (IntMap v) -> Element (IntMap v)) -> IntMap v -> Maybe (Element (IntMap v))

Container (Seq a)

Defined in Universum.Container.Class

Associated Types

type Element (Seq a)

Methods

toList :: Seq a -> [Element (Seq a)]

null :: Seq a -> Bool

foldr :: (Element (Seq a) -> b -> b) -> b -> Seq a -> b

foldl :: (b -> Element (Seq a) -> b) -> b -> Seq a -> b

foldl' :: (b -> Element (Seq a) -> b) -> b -> Seq a -> b

length :: Seq a -> Int

elem :: Element (Seq a) -> Seq a -> Bool

foldMap :: Monoid m => (Element (Seq a) -> m) -> Seq a -> m

fold :: Seq a -> Element (Seq a)

foldr' :: (Element (Seq a) -> b -> b) -> b -> Seq a -> b

notElem :: Element (Seq a) -> Seq a -> Bool

all :: (Element (Seq a) -> Bool) -> Seq a -> Bool

any :: (Element (Seq a) -> Bool) -> Seq a -> Bool

and :: Seq a -> Bool

or :: Seq a -> Bool

find :: (Element (Seq a) -> Bool) -> Seq a -> Maybe (Element (Seq a))

safeHead :: Seq a -> Maybe (Element (Seq a))

safeMaximum :: Seq a -> Maybe (Element (Seq a))

safeMinimum :: Seq a -> Maybe (Element (Seq a))

safeFoldr1 :: (Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Maybe (Element (Seq a))

safeFoldl1 :: (Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Maybe (Element (Seq a))

Ord v => Container (Set v)

Defined in Universum.Container.Class

Associated Types

type Element (Set v)

Methods

toList :: Set v -> [Element (Set v)]

null :: Set v -> Bool

foldr :: (Element (Set v) -> b -> b) -> b -> Set v -> b

foldl :: (b -> Element (Set v) -> b) -> b -> Set v -> b

foldl' :: (b -> Element (Set v) -> b) -> b -> Set v -> b

length :: Set v -> Int

elem :: Element (Set v) -> Set v -> Bool

foldMap :: Monoid m => (Element (Set v) -> m) -> Set v -> m

fold :: Set v -> Element (Set v)

foldr' :: (Element (Set v) -> b -> b) -> b -> Set v -> b

notElem :: Element (Set v) -> Set v -> Bool

all :: (Element (Set v) -> Bool) -> Set v -> Bool

any :: (Element (Set v) -> Bool) -> Set v -> Bool

and :: Set v -> Bool

or :: Set v -> Bool

find :: (Element (Set v) -> Bool) -> Set v -> Maybe (Element (Set v))

safeHead :: Set v -> Maybe (Element (Set v))

safeMaximum :: Set v -> Maybe (Element (Set v))

safeMinimum :: Set v -> Maybe (Element (Set v))

safeFoldr1 :: (Element (Set v) -> Element (Set v) -> Element (Set v)) -> Set v -> Maybe (Element (Set v))

safeFoldl1 :: (Element (Set v) -> Element (Set v) -> Element (Set v)) -> Set v -> Maybe (Element (Set v))

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

Defined in Universum.Container.Class

Associated Types

type Element (HashSet v)

Methods

toList :: HashSet v -> [Element (HashSet v)]

null :: HashSet v -> Bool

foldr :: (Element (HashSet v) -> b -> b) -> b -> HashSet v -> b

foldl :: (b -> Element (HashSet v) -> b) -> b -> HashSet v -> b

foldl' :: (b -> Element (HashSet v) -> b) -> b -> HashSet v -> b

length :: HashSet v -> Int

elem :: Element (HashSet v) -> HashSet v -> Bool

foldMap :: Monoid m => (Element (HashSet v) -> m) -> HashSet v -> m

fold :: HashSet v -> Element (HashSet v)

foldr' :: (Element (HashSet v) -> b -> b) -> b -> HashSet v -> b

notElem :: Element (HashSet v) -> HashSet v -> Bool

all :: (Element (HashSet v) -> Bool) -> HashSet v -> Bool

any :: (Element (HashSet v) -> Bool) -> HashSet v -> Bool

and :: HashSet v -> Bool

or :: HashSet v -> Bool

find :: (Element (HashSet v) -> Bool) -> HashSet v -> Maybe (Element (HashSet v))

safeHead :: HashSet v -> Maybe (Element (HashSet v))

safeMaximum :: HashSet v -> Maybe (Element (HashSet v))

safeMinimum :: HashSet v -> Maybe (Element (HashSet v))

safeFoldr1 :: (Element (HashSet v) -> Element (HashSet v) -> Element (HashSet v)) -> HashSet v -> Maybe (Element (HashSet v))

safeFoldl1 :: (Element (HashSet v) -> Element (HashSet v) -> Element (HashSet v)) -> HashSet v -> Maybe (Element (HashSet v))

Container (Vector a)

Defined in Universum.Container.Class

Associated Types

type Element (Vector a)

Methods

toList :: Vector a -> [Element (Vector a)]

null :: Vector a -> Bool

foldr :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b

foldl :: (b -> Element (Vector a) -> b) -> b -> Vector a -> b

foldl' :: (b -> Element (Vector a) -> b) -> b -> Vector a -> b

length :: Vector a -> Int

elem :: Element (Vector a) -> Vector a -> Bool

foldMap :: Monoid m => (Element (Vector a) -> m) -> Vector a -> m

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

foldr' :: (Element (Vector a) -> b -> b) -> b -> Vector a -> b

notElem :: Element (Vector a) -> Vector a -> Bool

all :: (Element (Vector a) -> Bool) -> Vector a -> Bool

any :: (Element (Vector a) -> Bool) -> Vector a -> Bool

and :: Vector a -> Bool

or :: Vector a -> Bool

find :: (Element (Vector a) -> Bool) -> Vector a -> Maybe (Element (Vector a))

safeHead :: Vector a -> Maybe (Element (Vector a))

safeMaximum :: Vector a -> Maybe (Element (Vector a))

safeMinimum :: Vector a -> Maybe (Element (Vector a))

safeFoldr1 :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Maybe (Element (Vector a))

safeFoldl1 :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Maybe (Element (Vector a))

(TypeError (DisallowInstance "Either") :: Constraint) => Container (Either a b)

Defined in Universum.Container.Class

Associated Types

type Element (Either a b)

Methods

toList :: Either a b -> [Element (Either a b)]

null :: Either a b -> Bool

foldr :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0

foldl :: (b0 -> Element (Either a b) -> b0) -> b0 -> Either a b -> b0

foldl' :: (b0 -> Element (Either a b) -> b0) -> b0 -> Either a b -> b0

length :: Either a b -> Int

elem :: Element (Either a b) -> Either a b -> Bool

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

fold :: Either a b -> Element (Either a b)

foldr' :: (Element (Either a b) -> b0 -> b0) -> b0 -> Either a b -> b0

notElem :: Element (Either a b) -> Either a b -> Bool

all :: (Element (Either a b) -> Bool) -> Either a b -> Bool

any :: (Element (Either a b) -> Bool) -> Either a b -> Bool

and :: Either a b -> Bool

or :: Either a b -> Bool

find :: (Element (Either a b) -> Bool) -> Either a b -> Maybe (Element (Either a b))

safeHead :: Either a b -> Maybe (Element (Either a b))

safeMaximum :: Either a b -> Maybe (Element (Either a b))

safeMinimum :: Either a b -> Maybe (Element (Either a b))

safeFoldr1 :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Maybe (Element (Either a b))

safeFoldl1 :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Maybe (Element (Either a b))

(TypeError (DisallowInstance "tuple") :: Constraint) => Container (a, b)

Defined in Universum.Container.Class

Associated Types

type Element (a, b)

Methods

toList :: (a, b) -> [Element (a, b)]

null :: (a, b) -> Bool

foldr :: (Element (a, b) -> b0 -> b0) -> b0 -> (a, b) -> b0

foldl :: (b0 -> Element (a, b) -> b0) -> b0 -> (a, b) -> b0

foldl' :: (b0 -> Element (a, b) -> b0) -> b0 -> (a, b) -> b0

length :: (a, b) -> Int

elem :: Element (a, b) -> (a, b) -> Bool

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

fold :: (a, b) -> Element (a, b)

foldr' :: (Element (a, b) -> b0 -> b0) -> b0 -> (a, b) -> b0

notElem :: Element (a, b) -> (a, b) -> Bool

all :: (Element (a, b) -> Bool) -> (a, b) -> Bool

any :: (Element (a, b) -> Bool) -> (a, b) -> Bool

and :: (a, b) -> Bool

or :: (a, b) -> Bool

find :: (Element (a, b) -> Bool) -> (a, b) -> Maybe (Element (a, b))

safeHead :: (a, b) -> Maybe (Element (a, b))

safeMaximum :: (a, b) -> Maybe (Element (a, b))

safeMinimum :: (a, b) -> Maybe (Element (a, b))

safeFoldr1 :: (Element (a, b) -> Element (a, b) -> Element (a, b)) -> (a, b) -> Maybe (Element (a, b))

safeFoldl1 :: (Element (a, b) -> Element (a, b) -> Element (a, b)) -> (a, b) -> Maybe (Element (a, b))

Container (Map k v)

Defined in Universum.Container.Class

Associated Types

type Element (Map k v)

Methods

toList :: Map k v -> [Element (Map k v)]

null :: Map k v -> Bool

foldr :: (Element (Map k v) -> b -> b) -> b -> Map k v -> b

foldl :: (b -> Element (Map k v) -> b) -> b -> Map k v -> b

foldl' :: (b -> Element (Map k v) -> b) -> b -> Map k v -> b

length :: Map k v -> Int

elem :: Element (Map k v) -> Map k v -> Bool

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

fold :: Map k v -> Element (Map k v)

foldr' :: (Element (Map k v) -> b -> b) -> b -> Map k v -> b

notElem :: Element (Map k v) -> Map k v -> Bool

all :: (Element (Map k v) -> Bool) -> Map k v -> Bool

any :: (Element (Map k v) -> Bool) -> Map k v -> Bool

and :: Map k v -> Bool

or :: Map k v -> Bool

find :: (Element (Map k v) -> Bool) -> Map k v -> Maybe (Element (Map k v))

safeHead :: Map k v -> Maybe (Element (Map k v))

safeMaximum :: Map k v -> Maybe (Element (Map k v))

safeMinimum :: Map k v -> Maybe (Element (Map k v))

safeFoldr1 :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Maybe (Element (Map k v))

safeFoldl1 :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Maybe (Element (Map k v))

Container (HashMap k v)

Defined in Universum.Container.Class

Associated Types

type Element (HashMap k v)

Methods

toList :: HashMap k v -> [Element (HashMap k v)]

null :: HashMap k v -> Bool

foldr :: (Element (HashMap k v) -> b -> b) -> b -> HashMap k v -> b

foldl :: (b -> Element (HashMap k v) -> b) -> b -> HashMap k v -> b

foldl' :: (b -> Element (HashMap k v) -> b) -> b -> HashMap k v -> b

length :: HashMap k v -> Int

elem :: Element (HashMap k v) -> HashMap k v -> Bool

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

fold :: HashMap k v -> Element (HashMap k v)

foldr' :: (Element (HashMap k v) -> b -> b) -> b -> HashMap k v -> b

notElem :: Element (HashMap k v) -> HashMap k v -> Bool

all :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Bool

any :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Bool

and :: HashMap k v -> Bool

or :: HashMap k v -> Bool

find :: (Element (HashMap k v) -> Bool) -> HashMap k v -> Maybe (Element (HashMap k v))

safeHead :: HashMap k v -> Maybe (Element (HashMap k v))

safeMaximum :: HashMap k v -> Maybe (Element (HashMap k v))

safeMinimum :: HashMap k v -> Maybe (Element (HashMap k v))

safeFoldr1 :: (Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> Maybe (Element (HashMap k v))

safeFoldl1 :: (Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> Maybe (Element (HashMap k v))

Container (Const a b)

Defined in Universum.Container.Class

Associated Types

type Element (Const a b)

Methods

toList :: Const a b -> [Element (Const a b)]

null :: Const a b -> Bool

foldr :: (Element (Const a b) -> b0 -> b0) -> b0 -> Const a b -> b0

foldl :: (b0 -> Element (Const a b) -> b0) -> b0 -> Const a b -> b0

foldl' :: (b0 -> Element (Const a b) -> b0) -> b0 -> Const a b -> b0

length :: Const a b -> Int

elem :: Element (Const a b) -> Const a b -> Bool

foldMap :: Monoid m => (Element (Const a b) -> m) -> Const a b -> m

fold :: Const a b -> Element (Const a b)

foldr' :: (Element (Const a b) -> b0 -> b0) -> b0 -> Const a b -> b0

notElem :: Element (Const a b) -> Const a b -> Bool

all :: (Element (Const a b) -> Bool) -> Const a b -> Bool

any :: (Element (Const a b) -> Bool) -> Const a b -> Bool

and :: Const a b -> Bool

or :: Const a b -> Bool

find :: (Element (Const a b) -> Bool) -> Const a b -> Maybe (Element (Const a b))

safeHead :: Const a b -> Maybe (Element (Const a b))

safeMaximum :: Const a b -> Maybe (Element (Const a b))

safeMinimum :: Const a b -> Maybe (Element (Const a b))

safeFoldr1 :: (Element (Const a b) -> Element (Const a b) -> Element (Const a b)) -> Const a b -> Maybe (Element (Const a b))

safeFoldl1 :: (Element (Const a b) -> Element (Const a b) -> Element (Const a b)) -> Const a b -> Maybe (Element (Const a b))

class ToPairs t where

Type class for data types that can be converted to List of Pairs. You can define ToPairs by just defining toPairs function.

But the following laws should be met:

toPairs m ≡ zip (keys m) (elems m)
keys      ≡ map fst . toPairs
elems     ≡ map snd . toPairs

Minimal complete definition

toPairs

Associated Types

type Key t :: Type

Type of keys of the mapping.

type Val t :: Type

Type of value of the mapping.

Methods

toPairs :: t -> [(Key t, Val t)]

Converts the structure to the list of the key-value pairs. >>> toPairs (HashMap.fromList [(a, "xxx"), (b, "yyy")]) [(a,"xxx"),(b,"yyy")]

keys :: t -> [Key t]

Converts the structure to the list of the keys.

>>> keys (HashMap.fromList [('a', "xxx"), ('b', "yyy")])
"ab"

elems :: t -> [Val t]

Converts the structure to the list of the values.

>>> elems (HashMap.fromList [('a', "xxx"), ('b', "yyy")])
["xxx","yyy"]

Instances

ToPairs (IntMap v)

Defined in Universum.Container.Class

Associated Types

type Key (IntMap v)

type Val (IntMap v)

Methods

toPairs :: IntMap v -> [(Key (IntMap v), Val (IntMap v))]

keys :: IntMap v -> [Key (IntMap v)]

elems :: IntMap v -> [Val (IntMap v)]

ToPairs (Map k v)

Defined in Universum.Container.Class

Associated Types

type Key (Map k v)

type Val (Map k v)

Methods

toPairs :: Map k v -> [(Key (Map k v), Val (Map k v))]

keys :: Map k v -> [Key (Map k v)]

elems :: Map k v -> [Val (Map k v)]

ToPairs (HashMap k v)

Defined in Universum.Container.Class

Associated Types

type Key (HashMap k v)

type Val (HashMap k v)

Methods

toPairs :: HashMap k v -> [(Key (HashMap k v), Val (HashMap k v))]

keys :: HashMap k v -> [Key (HashMap k v)]

elems :: HashMap k v -> [Val (HashMap k v)]

flipfoldl' :: (Container t, Element t ~ a) => (a -> b -> b) -> b -> t -> b

Similar to foldl' but takes a function with its arguments flipped.

>>> flipfoldl' (/) 5 [2,3] :: Rational
15 % 2

sum :: (Container t, Num (Element t)) => t -> Element t

Stricter version of sum.

>>> sum [1..10]
55
>>> sum (Just 3)
...
    • Do not use 'Foldable' methods on Maybe
      Suggestions:
          Instead of
              for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
          use
              whenJust  :: Applicative f => Maybe a    -> (a -> f ()) -> f ()
              whenRight :: Applicative f => Either l r -> (r -> f ()) -> f ()
...
          Instead of
              fold :: (Foldable t, Monoid m) => t m -> m
          use
              maybeToMonoid :: Monoid m => Maybe m -> m
...

product :: (Container t, Num (Element t)) => t -> Element t

Stricter version of product.

>>> product [1..10]
3628800
>>> product (Right 3)
...
    • Do not use 'Foldable' methods on Either
      Suggestions:
          Instead of
              for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
          use
              whenJust  :: Applicative f => Maybe a    -> (a -> f ()) -> f ()
              whenRight :: Applicative f => Either l r -> (r -> f ()) -> f ()
...
          Instead of
              fold :: (Foldable t, Monoid m) => t m -> m
          use
              maybeToMonoid :: Monoid m => Maybe m -> m
...

traverse_ :: (Container t, Applicative f) => (Element t -> f b) -> t -> f ()

Constrained to Container version of traverse_.

>>> traverse_ putTextLn ["foo", "bar"]
foo
bar

for_ :: (Container t, Applicative f) => t -> (Element t -> f b) -> f ()

Constrained to Container version of for_.

>>> for_ [1 .. 5 :: Int] $ \i -> when (even i) (print i)
2
4

mapM_ :: (Container t, Monad m) => (Element t -> m b) -> t -> m ()

Constrained to Container version of mapM_.

>>> mapM_ print [True, False]
True
False

forM_ :: (Container t, Monad m) => t -> (Element t -> m b) -> m ()

Constrained to Container version of forM_.

>>> forM_ [True, False] print
True
False

sequenceA_ :: (Container t, Applicative f, Element t ~ f a) => t -> f ()

Constrained to Container version of sequenceA_.

>>> sequenceA_ [putTextLn "foo", print True]
foo
True

sequence_ :: (Container t, Monad m, Element t ~ m a) => t -> m ()

Constrained to Container version of sequence_.

>>> sequence_ [putTextLn "foo", print True]
foo
True

asum :: (Container t, Alternative f, Element t ~ f a) => t -> f a

Constrained to Container version of asum.

>>> asum [Nothing, Just [False, True], Nothing, Just [True]]
Just [False,True]

module Universum.Container.Reexport