Containers

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

type family Element t

Type of element for some container. Implemented as a 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.

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

Type class for container. Fully compatible with Foldable. Contains very small and safe subset of Foldable functions.

Minimal complete definition

toList, null

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]

null :: t -> Bool

Checks whether container is empty.

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

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)

This instance makes Container compatible and overlappable by Foldable.

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

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 :: (NontrivialContainer 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_ :: (NontrivialContainer t, Monad m) => (Element t -> m b) -> t -> m ()

Constrained to NonTrivialContainer version of mapM_.

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

Constrained to NonTrivialContainer version of forM_.

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

Constrained to NonTrivialContainer version of traverse_.

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

Constrained to NonTrivialContainer version of for_.

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

Constrained to NonTrivialContainer version of sequenceA_.

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

Constrained to NonTrivialContainer version of sequence_.

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

Constrained to NonTrivialContainer 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

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

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