Universum.Container.Class

Reimagined approach for Foldable type hierarchy. Forbids usages of length function and similar over Maybe and other potentially unsafe data types. It was proposed to use -XTypeApplication for such cases. But this approach is not robust enough because programmers are human and can easily forget to do this. For discussion see this topic: Suggest explicit type application for Foldable length and friends

Foldable-like classes and methods

class ToList t where

Type class for data types that can be converted to List. Contains very small and safe subset of Foldable functions.

You can define Tolist by just defining toList function. But the following law should be met:

null ≡ null . toList

Associated Types

type Element t :: *

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.

Methods

toList :: t -> [Element t]

Convert container to list of elements.

>>> toList (Just True)
[True]
>>> toList @Text "aba"
"aba"
>>> :t toList @Text "aba"
toList @Text "aba" :: [Char]

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

Convert container to list of elements.

>>> toList (Just True)
[True]
>>> toList @Text "aba"
"aba"
>>> :t toList @Text "aba"
toList @Text "aba" :: [Char]

null :: t -> Bool

Checks whether container is empty.

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

Instances

ToList ByteString

Associated Types

type Element ByteString :: *

Methods

toList :: ByteString -> [Element ByteString]

null :: ByteString -> Bool

ToList ByteString

Associated Types

type Element ByteString :: *

Methods

toList :: ByteString -> [Element ByteString]

null :: ByteString -> Bool

ToList IntSet

Associated Types

type Element IntSet :: *

Methods

toList :: IntSet -> [Element IntSet]

null :: IntSet -> Bool

ToList Text

Associated Types

type Element Text :: *

Methods

toList :: Text -> [Element Text]

null :: Text -> Bool

ToList Text

Associated Types

type Element Text :: *

Methods

toList :: Text -> [Element Text]

null :: Text -> Bool

ToList [a]

Associated Types

type Element [a] :: *

Methods

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

null :: [a] -> Bool

ToList (Maybe a)

Associated Types

type Element (Maybe a) :: *

Methods

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

null :: Maybe a -> Bool

ToList (NonEmpty a)

Associated Types

type Element (NonEmpty a) :: *

Methods

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

null :: NonEmpty a -> Bool

ToList (ZipList a)

Associated Types

type Element (ZipList a) :: *

Methods

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

null :: ZipList a -> Bool

ToList (Identity a)

Associated Types

type Element (Identity a) :: *

Methods

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

null :: Identity a -> Bool

ToList (Dual a)

Associated Types

type Element (Dual a) :: *

Methods

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

null :: Dual a -> Bool

ToList (Sum a)

Associated Types

type Element (Sum a) :: *

Methods

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

null :: Sum a -> Bool

ToList (Product a)

Associated Types

type Element (Product a) :: *

Methods

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

null :: Product a -> Bool

ToList (First a)

Associated Types

type Element (First a) :: *

Methods

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

null :: First a -> Bool

ToList (Last a)

Associated Types

type Element (Last a) :: *

Methods

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

null :: Last a -> Bool

ToList (IntMap v)

Associated Types

type Element (IntMap v) :: *

Methods

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

null :: IntMap v -> Bool

ToList (Seq a)

Associated Types

type Element (Seq a) :: *

Methods

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

null :: Seq a -> Bool

ToList (Set v)

Associated Types

type Element (Set v) :: *

Methods

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

null :: Set v -> Bool

ToList (HashSet v)

Associated Types

type Element (HashSet v) :: *

Methods

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

null :: HashSet v -> Bool

ToList (Vector a)

Associated Types

type Element (Vector a) :: *

Methods

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

null :: Vector a -> Bool

ToList (Either a b)

Associated Types

type Element (Either a b) :: *

Methods

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

null :: Either a b -> Bool

TypeError Constraint (DisallowInstance "tuples") => ToList (a, b)

Associated Types

type Element (a, b) :: *

Methods

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

null :: (a, b) -> Bool

ToList (Map k v)

Associated Types

type Element (Map k v) :: *

Methods

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

null :: Map k v -> Bool

ToList (HashMap k v)

Associated Types

type Element (HashMap k v) :: *

Methods

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

null :: HashMap k v -> Bool

ToList (Const * a b)

Associated Types

type Element (Const * a b) :: *

Methods

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

null :: Const * a b -> Bool

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 of keys of the mapping.

type Val t :: *

Type of value of the mapping.

Methods

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

Converts the structure to the list of the key-value pairs. >>> import qualified Data.HashMap as HashMap >>> 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)

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)

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)

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

class ToList t => Container t where

A class for ToLists that aren't trivial like Maybe (e.g. can hold more than one value)

Associated Types

type ElementConstraint t :: * -> Constraint

Constraint for elements. This can be used to implement more efficient implementation of some methods.

Methods

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

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

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

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

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

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

length :: t -> Int

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

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

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

maximum :: Ord (Element t) => t -> Element t

maximum :: (Foldable f, t ~ f a, Element t ~ a, Ord (Element t)) => t -> Element t

minimum :: Ord (Element t) => t -> Element t

minimum :: (Foldable f, t ~ f a, Element t ~ a, Ord (Element t)) => t -> Element t

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

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

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

foldr1 :: (Element t -> Element t -> Element t) -> t -> Element t

foldl1 :: (Element t -> Element t -> Element t) -> t -> Element t

notElem :: ElementConstraint t (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)

Instances

Container ByteString

Associated Types

type ElementConstraint ByteString :: * -> Constraint

Methods

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

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

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

length :: ByteString -> Int

elem :: Element ByteString -> ByteString -> Bool

maximum :: ByteString -> Element ByteString

minimum :: ByteString -> Element ByteString

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

fold :: ByteString -> Element ByteString

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

foldr1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Element ByteString

foldl1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Element ByteString

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)

Container ByteString

Associated Types

type ElementConstraint ByteString :: * -> Constraint

Methods

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

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

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

length :: ByteString -> Int

elem :: Element ByteString -> ByteString -> Bool

maximum :: ByteString -> Element ByteString

minimum :: ByteString -> Element ByteString

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

fold :: ByteString -> Element ByteString

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

foldr1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Element ByteString

foldl1 :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> Element ByteString

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)

Container IntSet

Associated Types

type ElementConstraint IntSet :: * -> Constraint

Methods

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

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

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

length :: IntSet -> Int

elem :: Element IntSet -> IntSet -> Bool

maximum :: IntSet -> Element IntSet

minimum :: IntSet -> Element IntSet

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

fold :: IntSet -> Element IntSet

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

foldr1 :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Element IntSet

foldl1 :: (Element IntSet -> Element IntSet -> Element IntSet) -> IntSet -> Element IntSet

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)

Container Text

Associated Types

type ElementConstraint Text :: * -> Constraint

Methods

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

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

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

length :: Text -> Int

elem :: Element Text -> Text -> Bool

maximum :: Text -> Element Text

minimum :: Text -> Element Text

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

fold :: Text -> Element Text

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

foldr1 :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text

foldl1 :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text

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)

Container Text

Associated Types

type ElementConstraint Text :: * -> Constraint

Methods

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

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

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

length :: Text -> Int

elem :: Element Text -> Text -> Bool

maximum :: Text -> Element Text

minimum :: Text -> Element Text

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

fold :: Text -> Element Text

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

foldr1 :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text

foldl1 :: (Element Text -> Element Text -> Element Text) -> Text -> Element Text

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)

Container [a]

Associated Types

type ElementConstraint [a] :: * -> Constraint

Methods

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

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

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

length :: [a] -> Int

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

maximum :: [a] -> Element [a]

minimum :: [a] -> Element [a]

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

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

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

foldr1 :: (Element [a] -> Element [a] -> Element [a]) -> [a] -> Element [a]

foldl1 :: (Element [a] -> Element [a] -> Element [a]) -> [a] -> Element [a]

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

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

Associated Types

type ElementConstraint (Maybe a) :: * -> Constraint

Methods

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

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

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

length :: Maybe a -> Int

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

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

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

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

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

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

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

Container (NonEmpty a)

Associated Types

type ElementConstraint (NonEmpty a) :: * -> Constraint

Methods

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

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

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

length :: NonEmpty a -> Int

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

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

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

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

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

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

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

Container (ZipList a)

Associated Types

type ElementConstraint (ZipList a) :: * -> Constraint

Methods

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

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

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

length :: ZipList a -> Int

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

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

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

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

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

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

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

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

Associated Types

type ElementConstraint (Identity a) :: * -> Constraint

Methods

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

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

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

length :: Identity a -> Int

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

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

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

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

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

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

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

Container (Dual a)

Associated Types

type ElementConstraint (Dual a) :: * -> Constraint

Methods

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

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

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

length :: Dual a -> Int

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

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

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

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

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

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

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

Container (Sum a)

Associated Types

type ElementConstraint (Sum a) :: * -> Constraint

Methods

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

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

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

length :: Sum a -> Int

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

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

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

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

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

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

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

Container (Product a)

Associated Types

type ElementConstraint (Product a) :: * -> Constraint

Methods

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

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

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

length :: Product a -> Int

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

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

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

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

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

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

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

Container (First a)

Associated Types

type ElementConstraint (First a) :: * -> Constraint

Methods

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

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

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

length :: First a -> Int

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

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

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

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

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

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

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

Container (Last a)

Associated Types

type ElementConstraint (Last a) :: * -> Constraint

Methods

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

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

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

length :: Last a -> Int

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

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

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

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

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

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

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

Container (IntMap v)

Associated Types

type ElementConstraint (IntMap v) :: * -> Constraint

Methods

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

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

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

length :: IntMap v -> Int

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

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

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

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

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

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

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

Container (Seq a)

Associated Types

type ElementConstraint (Seq a) :: * -> Constraint

Methods

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

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

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

length :: Seq a -> Int

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

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

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

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

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

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

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

Container (Set v)

Associated Types

type ElementConstraint (Set v) :: * -> Constraint

Methods

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

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

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

length :: Set v -> Int

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

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

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

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

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

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

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

Container (HashSet v)

Associated Types

type ElementConstraint (HashSet v) :: * -> Constraint

Methods

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

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

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

length :: HashSet v -> Int

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

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

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

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

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

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

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

Container (Vector a)

Associated Types

type ElementConstraint (Vector a) :: * -> Constraint

Methods

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

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

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

length :: Vector a -> Int

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

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

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

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

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

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

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

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

Associated Types

type ElementConstraint (Either a b) :: * -> Constraint

Methods

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

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

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

length :: Either a b -> Int

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

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

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

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) -> b -> b) -> b -> Either a b -> b

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

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

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

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

Associated Types

type ElementConstraint (a, b) :: * -> Constraint

Methods

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

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

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

length :: (a, b) -> Int

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

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

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

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

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

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

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

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

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

Container (Map k v)

Associated Types

type ElementConstraint (Map k v) :: * -> Constraint

Methods

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' :: (Element (Map k v) -> b -> b) -> b -> Map k v -> b

length :: Map k v -> Int

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

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

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

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

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

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

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

Container (HashMap k v)

Associated Types

type ElementConstraint (HashMap k v) :: * -> Constraint

Methods

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' :: (Element (HashMap k v) -> b -> b) -> b -> HashMap k v -> b

length :: HashMap k v -> Int

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

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

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

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

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

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

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

Container (Const * a b)

Associated Types

type ElementConstraint (Const * a b) :: * -> Constraint

Methods

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

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

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

length :: Const * a b -> Int

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

maximum :: Const * a b -> Element (Const * a b)

minimum :: Const * a b -> Element (Const * a b)

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) -> b -> b) -> b -> Const * a b -> b

foldr1 :: (Element (Const * a b) -> Element (Const * a b) -> Element (Const * a b)) -> Const * a b -> Element (Const * a b)

foldl1 :: (Element (Const * a b) -> Element (Const * a b) -> Element (Const * a b)) -> Const * a b -> Element (Const * a b)

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

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

Stricter version of sum.

>>> sum [1..10]
55
>>> sum (Just 3)
<interactive>:43:1: error:
    • Do not use 'Foldable' methods on Maybe
    • In the expression: sum (Just 3)
      In an equation for ‘it’: it = sum (Just 3)

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

Stricter version of product.

>>> product [1..10]
3628800
>>> product (Right 3)
<interactive>:45:1: error:
    • Do not use 'Foldable' methods on Either
    • In the expression: product (Right 3)
      In an equation for ‘it’: it = product (Right 3)

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

Constrained to Container version of mapM_.

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

Constrained to Container version of forM_.

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

Constrained to Container version of traverse_.

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

Constrained to Container version of for_.

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

Constrained to Container version of sequenceA_.

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

Constrained to Container version of sequence_.

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

Constrained to Container version of asum.

Others

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")]

Minimal complete definition

one

Associated Types

type OneItem x

Methods

one :: OneItem x -> x

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

Instances

One ByteString

Associated Types

type OneItem ByteString :: *

Methods

one :: OneItem ByteString -> ByteString

One ByteString

Associated Types

type OneItem ByteString :: *

Methods

one :: OneItem ByteString -> ByteString

One IntSet

Associated Types

type OneItem IntSet :: *

Methods

one :: OneItem IntSet -> IntSet

One Text

Associated Types

type OneItem Text :: *

Methods

one :: OneItem Text -> Text

One Text

Associated Types

type OneItem Text :: *

Methods

one :: OneItem Text -> Text

One [a]

Associated Types

type OneItem [a] :: *

Methods

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

One (NonEmpty a)

Associated Types

type OneItem (NonEmpty a) :: *

Methods

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

One (IntMap v)

Associated Types

type OneItem (IntMap v) :: *

Methods

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

One (Seq a)

Associated Types

type OneItem (Seq a) :: *

Methods

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

One (Set v)

Associated Types

type OneItem (Set v) :: *

Methods

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

Hashable v => One (HashSet v)

Associated Types

type OneItem (HashSet v) :: *

Methods

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

Unbox a => One (Vector a)

Associated Types

type OneItem (Vector a) :: *

Methods

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

Storable a => One (Vector a)

Associated Types

type OneItem (Vector a) :: *

Methods

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

Prim a => One (Vector a)

Associated Types

type OneItem (Vector a) :: *

Methods

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

One (Vector a)

Associated Types

type OneItem (Vector a) :: *

Methods

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

One (Map k v)

Associated Types

type OneItem (Map k v) :: *

Methods

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

Hashable k => One (HashMap k v)

Associated Types

type OneItem (HashMap k v) :: *

Methods

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