Containers

Documentation

type family Element t

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

type Element (f a) = a

class Container t where

Minimal complete definition

toList, null

Methods

toList :: t -> [Element t]

null :: t -> Bool

Instances

Container ByteString

Methods

toList :: ByteString -> [Element ByteString]

null :: ByteString -> Bool

Container ByteString

Methods

toList :: ByteString -> [Element ByteString]

null :: ByteString -> Bool

Container IntSet

Methods

toList :: IntSet -> [Element IntSet]

null :: IntSet -> Bool

Container Text

Methods

toList :: Text -> [Element Text]

null :: Text -> Bool

Container Text

Methods

toList :: Text -> [Element Text]

null :: Text -> Bool

Foldable f => Container (f a)

Methods

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

null :: f a -> Bool

TypeError Constraint ((:<>:) (Text "Do not use 'Foldable' methods on ") (Text "tuples")) => Container (a, b)

Methods

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

null :: (a, b) -> Bool

class Container t => NontrivialContainer t where

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

Minimal complete definition

foldr, foldl, foldl', length, elem, maximum, minimum

Methods

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

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

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

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

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

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

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

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

length :: t -> Int

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

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

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

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)

head :: t -> Maybe (Element t)

Instances

NontrivialContainer ByteString

Methods

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

fold :: ByteString -> Element ByteString

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

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

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

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

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

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

length :: ByteString -> Int

elem :: Element ByteString -> ByteString -> Bool

maximum :: ByteString -> Element ByteString

minimum :: ByteString -> Element ByteString

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)

head :: ByteString -> Maybe (Element ByteString)

NontrivialContainer ByteString

Methods

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

fold :: ByteString -> Element ByteString

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

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

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

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

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

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

length :: ByteString -> Int

elem :: Element ByteString -> ByteString -> Bool

maximum :: ByteString -> Element ByteString

minimum :: ByteString -> Element ByteString

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)

head :: ByteString -> Maybe (Element ByteString)

NontrivialContainer IntSet

Methods

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

fold :: IntSet -> Element IntSet

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

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

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

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

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

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

length :: IntSet -> Int

elem :: Element IntSet -> IntSet -> Bool

maximum :: IntSet -> Element IntSet

minimum :: IntSet -> Element IntSet

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)

head :: IntSet -> Maybe (Element IntSet)

NontrivialContainer Text

Methods

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

fold :: Text -> Element Text

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

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

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

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

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

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

length :: Text -> Int

elem :: Element Text -> Text -> Bool

maximum :: Text -> Element Text

minimum :: Text -> Element Text

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)

head :: Text -> Maybe (Element Text)

NontrivialContainer Text

Methods

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

fold :: Text -> Element Text

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

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

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

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

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

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

length :: Text -> Int

elem :: Element Text -> Text -> Bool

maximum :: Text -> Element Text

minimum :: Text -> Element Text

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)

head :: Text -> Maybe (Element Text)

TypeError Constraint ((:<>:) (Text "Do not use 'Foldable' methods on ") (Text "Maybe")) => NontrivialContainer (Maybe a)

Methods

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

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

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)

length :: Maybe a -> Int

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

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

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

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

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

Foldable f => NontrivialContainer (f a)

Methods

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

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

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

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

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

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

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

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

length :: f a -> Int

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

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

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

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

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

and :: f a -> Bool

or :: f a -> Bool

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

head :: f a -> Maybe (Element (f a))

TypeError Constraint ((:<>:) (Text "Do not use 'Foldable' methods on ") (Text "Identity")) => NontrivialContainer (Identity a)

Methods

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

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

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)

length :: Identity a -> Int

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

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

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

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

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

TypeError Constraint ((:<>:) (Text "Do not use 'Foldable' methods on ") (Text "Either")) => NontrivialContainer (Either a b)

Methods

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

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' :: (b -> Element (Either a 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)

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)

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

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

TypeError Constraint ((:<>:) (Text "Do not use 'Foldable' methods on ") (Text "tuples")) => NontrivialContainer (a, b)

Methods

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

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

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

foldl' :: (b -> Element (a, 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)

length :: (a, b) -> Int

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

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

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

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

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

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

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

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

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

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

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

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

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

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