Control.Compactable

Documentation

class Compactable f where

This is a generalization of catMaybes as a new function compact. Compact has relations with Functor, Applicative, Monad, Alternative, and Traversable. In that we can use these class to provide the ability to operate on a data type by throwing away intermediate Nothings. This is useful for representing striping out values or failure.

In order to be Compactable, the following law should hold:

Kleisli composition

fmapMaybe (l <=< r) = fmapMaybe l . fmapMaybe r

If the data type is also a Functor the following should hold:

Functor identity 1

compact . fmap Just = id

Functor identity 2

fmapMaybe Just = id

Functor relation

compact = fmapMaybe id

According to Kmett, (Compactable f, Functor f) is a functor from the kleisli category of Maybe to the category of haskell data types. Kleisli Maybe -> Hask.

If the data type is also Applicative the following should hold:

Applicative identity 1

@compact . (pure Just *) = id

Applicative identity 2

applyMaybe (pure Just) = id

Applicative relation

compact = applyMaybe (pure id)

If the data type is also a Monad the following should hold:

Monad nameme

bindMaybe (return (Just x)) return = return x

Monad identity 1

flip bindMaybe (return . Just) = id

Monad identity 2

compact . (return . Just =<<) = id

Monad relation

compact = flip bindMaybe return

If the data type is also Alternative the following should hold:

Alternative identity

compact empty = empty

Alternative annihilation

compact (const Nothing <$> xs) = empty

If the data type is also Traversable the following should hold:

Traversable name me

traverseMaybe (pure . Just) = pure

Traversable composition

Compose . fmap (traverseMaybe f) . traverseMaybe g = traverseMaybe (Compose . fmap (traverseMaybe f) . g)

Traversable name me

traverse f = traverseMaybe (fmap Just . f)

Traversable naturality

t . traverseMaybe f = traverseMaybe (t . f)

If you know of more useful laws, or have better names for the ones above (especially those marked "name me"). Please let me know.

Methods

compact :: f (Maybe a) -> f a

compact :: (Monad f, Alternative f) => f (Maybe a) -> f a

fmapMaybe :: Functor f => (a -> Maybe b) -> f a -> f b

applyMaybe :: Applicative f => f (a -> Maybe b) -> f a -> f b

bindMaybe :: Monad f => f a -> (a -> f (Maybe b)) -> f b

traverseMaybe :: (Applicative g, Traversable f) => (a -> g (Maybe b)) -> f a -> g (f b)

Instances

Compactable []

Methods

compact :: [Maybe a] -> [a]

fmapMaybe :: Functor [] => (a -> Maybe b) -> [a] -> [b]

applyMaybe :: Applicative [] => [a -> Maybe b] -> [a] -> [b]

bindMaybe :: Monad [] => [a] -> (a -> [Maybe b]) -> [b]

traverseMaybe :: (Applicative g, Traversable []) => (a -> g (Maybe b)) -> [a] -> g [b]

Compactable Maybe

Methods

compact :: Maybe (Maybe a) -> Maybe a

fmapMaybe :: Functor Maybe => (a -> Maybe b) -> Maybe a -> Maybe b

applyMaybe :: Applicative Maybe => Maybe (a -> Maybe b) -> Maybe a -> Maybe b

bindMaybe :: Monad Maybe => Maybe a -> (a -> Maybe (Maybe b)) -> Maybe b

traverseMaybe :: (Applicative g, Traversable Maybe) => (a -> g (Maybe b)) -> Maybe a -> g (Maybe b)

Compactable IO

Methods

compact :: IO (Maybe a) -> IO a

fmapMaybe :: Functor IO => (a -> Maybe b) -> IO a -> IO b

applyMaybe :: Applicative IO => IO (a -> Maybe b) -> IO a -> IO b

bindMaybe :: Monad IO => IO a -> (a -> IO (Maybe b)) -> IO b

traverseMaybe :: (Applicative g, Traversable IO) => (a -> g (Maybe b)) -> IO a -> g (IO b)

Compactable Option

Methods

compact :: Option (Maybe a) -> Option a

fmapMaybe :: Functor Option => (a -> Maybe b) -> Option a -> Option b

applyMaybe :: Applicative Option => Option (a -> Maybe b) -> Option a -> Option b

bindMaybe :: Monad Option => Option a -> (a -> Option (Maybe b)) -> Option b

traverseMaybe :: (Applicative g, Traversable Option) => (a -> g (Maybe b)) -> Option a -> g (Option b)

Compactable STM

Methods

compact :: STM (Maybe a) -> STM a

fmapMaybe :: Functor STM => (a -> Maybe b) -> STM a -> STM b

applyMaybe :: Applicative STM => STM (a -> Maybe b) -> STM a -> STM b

bindMaybe :: Monad STM => STM a -> (a -> STM (Maybe b)) -> STM b

traverseMaybe :: (Applicative g, Traversable STM) => (a -> g (Maybe b)) -> STM a -> g (STM b)

Compactable ReadPrec

Methods

compact :: ReadPrec (Maybe a) -> ReadPrec a

fmapMaybe :: Functor ReadPrec => (a -> Maybe b) -> ReadPrec a -> ReadPrec b

applyMaybe :: Applicative ReadPrec => ReadPrec (a -> Maybe b) -> ReadPrec a -> ReadPrec b

bindMaybe :: Monad ReadPrec => ReadPrec a -> (a -> ReadPrec (Maybe b)) -> ReadPrec b

traverseMaybe :: (Applicative g, Traversable ReadPrec) => (a -> g (Maybe b)) -> ReadPrec a -> g (ReadPrec b)

Compactable ReadP

Methods

compact :: ReadP (Maybe a) -> ReadP a

fmapMaybe :: Functor ReadP => (a -> Maybe b) -> ReadP a -> ReadP b

applyMaybe :: Applicative ReadP => ReadP (a -> Maybe b) -> ReadP a -> ReadP b

bindMaybe :: Monad ReadP => ReadP a -> (a -> ReadP (Maybe b)) -> ReadP b

traverseMaybe :: (Applicative g, Traversable ReadP) => (a -> g (Maybe b)) -> ReadP a -> g (ReadP b)

Compactable IntMap

Methods

compact :: IntMap (Maybe a) -> IntMap a

fmapMaybe :: Functor IntMap => (a -> Maybe b) -> IntMap a -> IntMap b

applyMaybe :: Applicative IntMap => IntMap (a -> Maybe b) -> IntMap a -> IntMap b

bindMaybe :: Monad IntMap => IntMap a -> (a -> IntMap (Maybe b)) -> IntMap b

traverseMaybe :: (Applicative g, Traversable IntMap) => (a -> g (Maybe b)) -> IntMap a -> g (IntMap b)

Compactable Seq

Methods

compact :: Seq (Maybe a) -> Seq a

fmapMaybe :: Functor Seq => (a -> Maybe b) -> Seq a -> Seq b

applyMaybe :: Applicative Seq => Seq (a -> Maybe b) -> Seq a -> Seq b

bindMaybe :: Monad Seq => Seq a -> (a -> Seq (Maybe b)) -> Seq b

traverseMaybe :: (Applicative g, Traversable Seq) => (a -> g (Maybe b)) -> Seq a -> g (Seq b)

Compactable Vector

Methods

compact :: Vector (Maybe a) -> Vector a

fmapMaybe :: Functor Vector => (a -> Maybe b) -> Vector a -> Vector b

applyMaybe :: Applicative Vector => Vector (a -> Maybe b) -> Vector a -> Vector b

bindMaybe :: Monad Vector => Vector a -> (a -> Vector (Maybe b)) -> Vector b

traverseMaybe :: (Applicative g, Traversable Vector) => (a -> g (Maybe b)) -> Vector a -> g (Vector b)

Compactable (Proxy *)

Methods

compact :: Proxy * (Maybe a) -> Proxy * a

fmapMaybe :: Functor (Proxy *) => (a -> Maybe b) -> Proxy * a -> Proxy * b

applyMaybe :: Applicative (Proxy *) => Proxy * (a -> Maybe b) -> Proxy * a -> Proxy * b

bindMaybe :: Monad (Proxy *) => Proxy * a -> (a -> Proxy * (Maybe b)) -> Proxy * b

traverseMaybe :: (Applicative g, Traversable (Proxy *)) => (a -> g (Maybe b)) -> Proxy * a -> g (Proxy * b)

Compactable (Map k)

Methods

compact :: Map k (Maybe a) -> Map k a

fmapMaybe :: Functor (Map k) => (a -> Maybe b) -> Map k a -> Map k b

applyMaybe :: Applicative (Map k) => Map k (a -> Maybe b) -> Map k a -> Map k b

bindMaybe :: Monad (Map k) => Map k a -> (a -> Map k (Maybe b)) -> Map k b

traverseMaybe :: (Applicative g, Traversable (Map k)) => (a -> g (Maybe b)) -> Map k a -> g (Map k b)

(Compactable f, Compactable g) => Compactable (Product * f g)

Methods

compact :: Product * f g (Maybe a) -> Product * f g a

fmapMaybe :: Functor (Product * f g) => (a -> Maybe b) -> Product * f g a -> Product * f g b

applyMaybe :: Applicative (Product * f g) => Product * f g (a -> Maybe b) -> Product * f g a -> Product * f g b

bindMaybe :: Monad (Product * f g) => Product * f g a -> (a -> Product * f g (Maybe b)) -> Product * f g b

traverseMaybe :: (Applicative g, Traversable (Product * f g)) => (a -> g (Maybe b)) -> Product * f g a -> g (Product * f g b)

(Functor f, Functor g, Compactable g) => Compactable (Compose * * f g)

Methods

compact :: Compose * * f g (Maybe a) -> Compose * * f g a

fmapMaybe :: Functor (Compose * * f g) => (a -> Maybe b) -> Compose * * f g a -> Compose * * f g b

applyMaybe :: Applicative (Compose * * f g) => Compose * * f g (a -> Maybe b) -> Compose * * f g a -> Compose * * f g b

bindMaybe :: Monad (Compose * * f g) => Compose * * f g a -> (a -> Compose * * f g (Maybe b)) -> Compose * * f g b

traverseMaybe :: (Applicative g, Traversable (Compose * * f g)) => (a -> g (Maybe b)) -> Compose * * f g a -> g (Compose * * f g b)

fforMaybe :: (Compactable f, Functor f) => f a -> (a -> Maybe b) -> f b

filter :: (Compactable f, Functor f) => (a -> Bool) -> f a -> f a

fmapMaybeM :: (Compactable f, Monad f) => (a -> MaybeT f b) -> f a -> f b

fforMaybeM :: (Compactable f, Monad f) => f a -> (a -> MaybeT f b) -> f b

applyMaybeM :: (Compactable f, Monad f) => f (a -> MaybeT f b) -> f a -> f b

bindMaybeM :: (Compactable f, Monad f) => f a -> (a -> f (MaybeT f b)) -> f b

traverseMaybeM :: (Monad m, Compactable t, Traversable t) => (a -> MaybeT m b) -> t a -> m (t b)