Data.FoldApp.Generic

The most generic definitions for folding function applications.

Documentation

class Converter conv where

Class of constraints which feature a function to convert a value of one type to a value of another.

Minimal complete definition

convert

Methods

convert :: conv a b => a -> b

Instances

Converter ((~) *)

Methods

convert :: (* ~ a) b => a -> b

class (Converter conv, Infer conv p r f) => FoldlApp conv p r f where

Class defining left-associative folds of function applications. No other instances need be defined.

Minimal complete definition

foldlApp

Methods

foldlApp :: (r -> p -> r) -> r -> f

Left-associative fold of function applications.

Instances

(Converter conv, Infer conv p r r) => FoldlApp conv p r r

Methods

foldlApp :: (r -> p -> r) -> r -> r

(Converter conv, Infer conv p r (x -> f), FoldlApp conv p r f) => FoldlApp conv p r (x -> f)

Methods

foldlApp :: (r -> p -> r) -> r -> x -> f

class (Converter conv, Infer conv p r f) => FoldrApp conv p r f

Class defining right-associative folds of function applications. No other instances need be defined.

Minimal complete definition

foldrAppImpl

Instances

(Converter conv, Infer conv p r r) => FoldrApp conv p r r

Methods

foldrAppImpl :: (p -> r -> r) -> (r -> r) -> r -> r

(Converter conv, Infer conv p r (x -> f), FoldrApp conv p r f) => FoldrApp conv p r (x -> f)

Methods

foldrAppImpl :: (p -> r -> r) -> (r -> r) -> r -> x -> f

class Applicative m => Monad m

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following laws:

• return a >>= k  =  k a

• m >>= return  =  m

• m >>= (\x -> k x >>= h)  =  (m >>= k) >>= h

Furthermore, the Monad and Applicative operations should relate as follows:

• pure = return

• (<*>) = ap

The above laws imply:

• fmap f xs  =  xs >>= return . f

• (>>) = (*>)

and that pure and (<*>) satisfy the applicative functor laws.

The instances of Monad for lists, Maybe and IO defined in the Prelude satisfy these laws.

Minimal complete definition

(>>=)

Instances

Monad []

Methods

(>>=) :: [a] -> (a -> [b]) -> [b]

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

return :: a -> [a]

fail :: String -> [a]

Monad Maybe

Methods

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

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

return :: a -> Maybe a

fail :: String -> Maybe a

Monad IO

Methods

(>>=) :: IO a -> (a -> IO b) -> IO b

(>>) :: IO a -> IO b -> IO b

return :: a -> IO a

fail :: String -> IO a

Monad U1

Methods

(>>=) :: U1 a -> (a -> U1 b) -> U1 b

(>>) :: U1 a -> U1 b -> U1 b

return :: a -> U1 a

fail :: String -> U1 a

Monad Par1

Methods

(>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b

(>>) :: Par1 a -> Par1 b -> Par1 b

return :: a -> Par1 a

fail :: String -> Par1 a

Monad Identity

Methods

(>>=) :: Identity a -> (a -> Identity b) -> Identity b

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

return :: a -> Identity a

fail :: String -> Identity a

Monad Min

Methods

(>>=) :: Min a -> (a -> Min b) -> Min b

(>>) :: Min a -> Min b -> Min b

return :: a -> Min a

fail :: String -> Min a

Monad Max

Methods

(>>=) :: Max a -> (a -> Max b) -> Max b

(>>) :: Max a -> Max b -> Max b

return :: a -> Max a

fail :: String -> Max a

Monad First

Methods

(>>=) :: First a -> (a -> First b) -> First b

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

return :: a -> First a

fail :: String -> First a

Monad Last

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b

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

return :: a -> Last a

fail :: String -> Last a

Monad Option

Methods

(>>=) :: Option a -> (a -> Option b) -> Option b

(>>) :: Option a -> Option b -> Option b

return :: a -> Option a

fail :: String -> Option a

Monad NonEmpty

Methods

(>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b

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

return :: a -> NonEmpty a

fail :: String -> NonEmpty a

Monad Complex

Methods

(>>=) :: Complex a -> (a -> Complex b) -> Complex b

(>>) :: Complex a -> Complex b -> Complex b

return :: a -> Complex a

fail :: String -> Complex a

Monad Dual

Methods

(>>=) :: Dual a -> (a -> Dual b) -> Dual b

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

return :: a -> Dual a

fail :: String -> Dual a

Monad Sum

Methods

(>>=) :: Sum a -> (a -> Sum b) -> Sum b

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

return :: a -> Sum a

fail :: String -> Sum a

Monad Product

Methods

(>>=) :: Product a -> (a -> Product b) -> Product b

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

return :: a -> Product a

fail :: String -> Product a

Monad First

Methods

(>>=) :: First a -> (a -> First b) -> First b

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

return :: a -> First a

fail :: String -> First a

Monad Last

Methods

(>>=) :: Last a -> (a -> Last b) -> Last b

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

return :: a -> Last a

fail :: String -> Last a

Monad Seq

Methods

(>>=) :: Seq a -> (a -> Seq b) -> Seq b

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

return :: a -> Seq a

fail :: String -> Seq a

Monad ((->) r)

Methods

(>>=) :: (r -> a) -> (a -> r -> b) -> r -> b

(>>) :: (r -> a) -> (r -> b) -> r -> b

return :: a -> r -> a

fail :: String -> r -> a

Monad (Either e)

Methods

(>>=) :: Either e a -> (a -> Either e b) -> Either e b

(>>) :: Either e a -> Either e b -> Either e b

return :: a -> Either e a

fail :: String -> Either e a

Monad f => Monad (Rec1 f)

Methods

(>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b

(>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b

return :: a -> Rec1 f a

fail :: String -> Rec1 f a

Monoid a => Monad ((,) a)

Methods

(>>=) :: (a, a) -> (a -> (a, b)) -> (a, b)

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

return :: a -> (a, a)

fail :: String -> (a, a)

Monad m => Monad (WrappedMonad m)

Methods

(>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b

(>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

return :: a -> WrappedMonad m a

fail :: String -> WrappedMonad m a

Monad (Proxy *)

Methods

(>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b

(>>) :: Proxy * a -> Proxy * b -> Proxy * b

return :: a -> Proxy * a

fail :: String -> Proxy * a

Monad (State s)

Methods

(>>=) :: State s a -> (a -> State s b) -> State s b

(>>) :: State s a -> State s b -> State s b

return :: a -> State s a

fail :: String -> State s a

(Monad f, Monad g) => Monad ((:*:) f g)

Methods

(>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b

(>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

return :: a -> (f :*: g) a

fail :: String -> (f :*: g) a

Monad f => Monad (Alt * f)

Methods

(>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b

(>>) :: Alt * f a -> Alt * f b -> Alt * f b

return :: a -> Alt * f a

fail :: String -> Alt * f a

Monad f => Monad (M1 i c f)

Methods

(>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b

(>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b

return :: a -> M1 i c f a

fail :: String -> M1 i c f a

foldlMApp :: forall conv m p r f. (Monad m, FoldlApp conv p (m r) f) => (r -> p -> m r) -> r -> f

Monadic left-associative fold of function applications.

foldrApp :: forall conv p r f. FoldrApp conv p r f => (p -> r -> r) -> r -> f

Right-associative fold of function applications.

foldrMApp :: forall conv m p r f. (Monad m, FoldrApp conv p (m r) f) => (p -> r -> m r) -> r -> f

Monadic right-associative fold of function applications.