Parameterized.Control.Monad.Trans.Reader

Documentation

newtype OverlappingWhichReader m r a

Given a Reader that accepts Which a, and another Reader that accepts Which b make a reader that accepts Which (AppendUnique a b) and runs both readers if possible, where the types in Which a and Which b may overlap, but with the compile time constraint that all the types in (AppendUnique a b) are distinct.

Constructors

OverlappingWhichReader

Fields

• runOverlappingWhichReader :: ReaderT r m a

Instances

Alternative m => PEmpty * (OverlappingWhichReader m) (Which ([] Type))

Methods

pempty :: PUnary (OverlappingWhichReader m) (Which [Type]) id a

Applicative m => PPointed * (OverlappingWhichReader m) (Which ([] Type))

Methods

ppure :: a -> PUnary (OverlappingWhichReader m) (Which [Type]) id a

(Alternative m, Reinterpret b c, Reinterpret a c, (~) [Type] c (AppendUnique Type a b)) => PAlternative * (OverlappingWhichReader m) (Which a) (Which b) (Which c)

Methods

pappend :: PUnary (OverlappingWhichReader m) (Which a) (Which b) a -> PUnary (OverlappingWhichReader m) (Which a) (Which c) a -> PUnary (OverlappingWhichReader m) (Which a) v a

Monad m => Monad (OverlappingWhichReader m r)

Methods

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

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

return :: a -> OverlappingWhichReader m r a

fail :: String -> OverlappingWhichReader m r a

Functor m => Functor (OverlappingWhichReader m r)

Methods

fmap :: (a -> b) -> OverlappingWhichReader m r a -> OverlappingWhichReader m r b

(<$) :: a -> OverlappingWhichReader m r b -> OverlappingWhichReader m r a

MonadFix m => MonadFix (OverlappingWhichReader m r)

Methods

mfix :: (a -> OverlappingWhichReader m r a) -> OverlappingWhichReader m r a

MonadFail m => MonadFail (OverlappingWhichReader m r)

Methods

fail :: String -> OverlappingWhichReader m r a

Applicative m => Applicative (OverlappingWhichReader m r)

Methods

pure :: a -> OverlappingWhichReader m r a

(<*>) :: OverlappingWhichReader m r (a -> b) -> OverlappingWhichReader m r a -> OverlappingWhichReader m r b

(*>) :: OverlappingWhichReader m r a -> OverlappingWhichReader m r b -> OverlappingWhichReader m r b

(<*) :: OverlappingWhichReader m r a -> OverlappingWhichReader m r b -> OverlappingWhichReader m r a

MonadZip m => MonadZip (OverlappingWhichReader m r)

Methods

mzip :: OverlappingWhichReader m r a -> OverlappingWhichReader m r b -> OverlappingWhichReader m r (a, b)

mzipWith :: (a -> b -> c) -> OverlappingWhichReader m r a -> OverlappingWhichReader m r b -> OverlappingWhichReader m r c

munzip :: OverlappingWhichReader m r (a, b) -> (OverlappingWhichReader m r a, OverlappingWhichReader m r b)

MonadIO m => MonadIO (OverlappingWhichReader m r)

Methods

liftIO :: IO a -> OverlappingWhichReader m r a

Alternative m => Alternative (OverlappingWhichReader m r)

Methods

empty :: OverlappingWhichReader m r a

(<|>) :: OverlappingWhichReader m r a -> OverlappingWhichReader m r a -> OverlappingWhichReader m r a

some :: OverlappingWhichReader m r a -> OverlappingWhichReader m r [a]

many :: OverlappingWhichReader m r a -> OverlappingWhichReader m r [a]

MonadPlus m => MonadPlus (OverlappingWhichReader m r)

Methods

mzero :: OverlappingWhichReader m r a

mplus :: OverlappingWhichReader m r a -> OverlappingWhichReader m r a -> OverlappingWhichReader m r a

Generic (OverlappingWhichReader m r a)

Associated Types

type Rep (OverlappingWhichReader m r a) :: * -> *

Methods

from :: OverlappingWhichReader m r a -> Rep (OverlappingWhichReader m r a) x

to :: Rep (OverlappingWhichReader m r a) x -> OverlappingWhichReader m r a

type PUnary * (OverlappingWhichReader m) r

type PUnary * (OverlappingWhichReader m) r = OverlappingWhichReader m r

type Rep (OverlappingWhichReader m r a)

type Rep (OverlappingWhichReader m r a) = D1 (MetaData "OverlappingWhichReader" "Parameterized.Control.Monad.Trans.Reader" "parameterized-0.4.0.0-H8NmV43vqoy2pwNNNesLX0" True) (C1 (MetaCons "OverlappingWhichReader" PrefixI True) (S1 (MetaSel (Just Symbol "runOverlappingWhichReader") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ReaderT * r m a))))

newtype DistinctWhichReader m r a

Given a Reader that accepts Which a, and another Reader that accepts Which b make a reader that accepts Which (Append a b) and only run one of the readers for the correct Which type, with a compile-time contraint that the types in Which a are distinct from the type in Which b The advantage of DistinctWhichReader over OverlappingWhichReader is that pappend doesn't require the inner monad m to be an Alternative. NB. PEmpty still requires Alternative but you don't need to be an instance of PEmpty (analogous to Semigroup)

Constructors

DistinctWhichReader

Fields

• runDistinctWhichReader :: ReaderT r m a

Instances

Alternative m => PEmpty * (DistinctWhichReader m) (Which ([] Type))

Methods

pempty :: PUnary (DistinctWhichReader m) (Which [Type]) id a

Applicative m => PPointed * (DistinctWhichReader m) (Which ([] Type))

Methods

ppure :: a -> PUnary (DistinctWhichReader m) (Which [Type]) id a

(Reinterpret b c, (~) [Type] (Complement Type c b) a, (~) [Type] (Complement Type c a) b, (~) [Type] c (Append Type a b)) => PAlternative * (DistinctWhichReader m) (Which a) (Which b) (Which c)

Methods

pappend :: PUnary (DistinctWhichReader m) (Which a) (Which b) a -> PUnary (DistinctWhichReader m) (Which a) (Which c) a -> PUnary (DistinctWhichReader m) (Which a) v a

Monad m => Monad (DistinctWhichReader m r)

Methods

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

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

return :: a -> DistinctWhichReader m r a

fail :: String -> DistinctWhichReader m r a

Functor m => Functor (DistinctWhichReader m r)

Methods

fmap :: (a -> b) -> DistinctWhichReader m r a -> DistinctWhichReader m r b

(<$) :: a -> DistinctWhichReader m r b -> DistinctWhichReader m r a

MonadFix m => MonadFix (DistinctWhichReader m r)

Methods

mfix :: (a -> DistinctWhichReader m r a) -> DistinctWhichReader m r a

MonadFail m => MonadFail (DistinctWhichReader m r)

Methods

fail :: String -> DistinctWhichReader m r a

Applicative m => Applicative (DistinctWhichReader m r)

Methods

pure :: a -> DistinctWhichReader m r a

(<*>) :: DistinctWhichReader m r (a -> b) -> DistinctWhichReader m r a -> DistinctWhichReader m r b

(*>) :: DistinctWhichReader m r a -> DistinctWhichReader m r b -> DistinctWhichReader m r b

(<*) :: DistinctWhichReader m r a -> DistinctWhichReader m r b -> DistinctWhichReader m r a

MonadZip m => MonadZip (DistinctWhichReader m r)

Methods

mzip :: DistinctWhichReader m r a -> DistinctWhichReader m r b -> DistinctWhichReader m r (a, b)

mzipWith :: (a -> b -> c) -> DistinctWhichReader m r a -> DistinctWhichReader m r b -> DistinctWhichReader m r c

munzip :: DistinctWhichReader m r (a, b) -> (DistinctWhichReader m r a, DistinctWhichReader m r b)

MonadIO m => MonadIO (DistinctWhichReader m r)

Methods

liftIO :: IO a -> DistinctWhichReader m r a

Alternative m => Alternative (DistinctWhichReader m r)

Methods

empty :: DistinctWhichReader m r a

(<|>) :: DistinctWhichReader m r a -> DistinctWhichReader m r a -> DistinctWhichReader m r a

some :: DistinctWhichReader m r a -> DistinctWhichReader m r [a]

many :: DistinctWhichReader m r a -> DistinctWhichReader m r [a]

MonadPlus m => MonadPlus (DistinctWhichReader m r)

Methods

mzero :: DistinctWhichReader m r a

mplus :: DistinctWhichReader m r a -> DistinctWhichReader m r a -> DistinctWhichReader m r a

Generic (DistinctWhichReader m r a)

Associated Types

type Rep (DistinctWhichReader m r a) :: * -> *

Methods

from :: DistinctWhichReader m r a -> Rep (DistinctWhichReader m r a) x

to :: Rep (DistinctWhichReader m r a) x -> DistinctWhichReader m r a

type PUnary * (DistinctWhichReader m) r

type PUnary * (DistinctWhichReader m) r = DistinctWhichReader m r

type Rep (DistinctWhichReader m r a)

type Rep (DistinctWhichReader m r a) = D1 (MetaData "DistinctWhichReader" "Parameterized.Control.Monad.Trans.Reader" "parameterized-0.4.0.0-H8NmV43vqoy2pwNNNesLX0" True) (C1 (MetaCons "DistinctWhichReader" PrefixI True) (S1 (MetaSel (Just Symbol "runDistinctWhichReader") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ReaderT * r m a))))

newtype ManyReader m r a

Given a Reader that accepts Many a, and another Reader that accepts Many b make a reader that accepts Many (AppendUnique a b) with the compile time constraint that all the types in (AppendUnique a b) are distinct.

Constructors

ManyReader

Fields

• runManyReader :: ReaderT r m a

Instances

Alternative m => PEmpty * (ManyReader m) (Many ([] Type))

Methods

pempty :: PUnary (ManyReader m) (Many [Type]) id a

Applicative m => PPointed * (ManyReader m) (Many ([] Type))

Methods

ppure :: a -> PUnary (ManyReader m) (Many [Type]) id a

(Alternative m, Select a c, Select b c, (~) [Type] c (AppendUnique Type a b)) => PAlternative * (ManyReader m) (Many a) (Many b) (Many c)

Methods

pappend :: PUnary (ManyReader m) (Many a) (Many b) a -> PUnary (ManyReader m) (Many a) (Many c) a -> PUnary (ManyReader m) (Many a) v a

(Functor (ManyReader m (Many c)), Applicative m, Select a c, Select b c, (~) [Type] c (AppendUnique Type a b)) => PApplicative * (ManyReader m) (Many a) (Many b) (Many c)

Methods

papply :: PUnary (ManyReader m) (Many a) (Many b) (a -> b) -> PUnary (ManyReader m) (Many a) (Many c) a -> PUnary (ManyReader m) (Many a) v b

(Functor (ManyReader m (Many c)), Monad m, Select a c, Select b c, (~) [Type] c (AppendUnique Type a b)) => PMonad * (ManyReader m) (Many a) (Many b) (Many c)

Methods

pbind :: PUnary (ManyReader m) (Many a) (Many b) a -> (a -> PUnary (ManyReader m) (Many a) (Many c) b) -> PUnary (ManyReader m) (Many a) v b

Monad m => Monad (ManyReader m r)

Methods

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

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

return :: a -> ManyReader m r a

fail :: String -> ManyReader m r a

Functor m => Functor (ManyReader m r)

Methods

fmap :: (a -> b) -> ManyReader m r a -> ManyReader m r b

(<$) :: a -> ManyReader m r b -> ManyReader m r a

MonadFix m => MonadFix (ManyReader m r)

Methods

mfix :: (a -> ManyReader m r a) -> ManyReader m r a

MonadFail m => MonadFail (ManyReader m r)

Methods

fail :: String -> ManyReader m r a

Applicative m => Applicative (ManyReader m r)

Methods

pure :: a -> ManyReader m r a

(<*>) :: ManyReader m r (a -> b) -> ManyReader m r a -> ManyReader m r b

(*>) :: ManyReader m r a -> ManyReader m r b -> ManyReader m r b

(<*) :: ManyReader m r a -> ManyReader m r b -> ManyReader m r a

MonadZip m => MonadZip (ManyReader m r)

Methods

mzip :: ManyReader m r a -> ManyReader m r b -> ManyReader m r (a, b)

mzipWith :: (a -> b -> c) -> ManyReader m r a -> ManyReader m r b -> ManyReader m r c

munzip :: ManyReader m r (a, b) -> (ManyReader m r a, ManyReader m r b)

MonadIO m => MonadIO (ManyReader m r)

Methods

liftIO :: IO a -> ManyReader m r a

Alternative m => Alternative (ManyReader m r)

Methods

empty :: ManyReader m r a

(<|>) :: ManyReader m r a -> ManyReader m r a -> ManyReader m r a

some :: ManyReader m r a -> ManyReader m r [a]

many :: ManyReader m r a -> ManyReader m r [a]

MonadPlus m => MonadPlus (ManyReader m r)

Methods

mzero :: ManyReader m r a

mplus :: ManyReader m r a -> ManyReader m r a -> ManyReader m r a

Generic (ManyReader m r a)

Associated Types

type Rep (ManyReader m r a) :: * -> *

Methods

from :: ManyReader m r a -> Rep (ManyReader m r a) x

to :: Rep (ManyReader m r a) x -> ManyReader m r a

type PUnary * (ManyReader m) r

type PUnary * (ManyReader m) r = ManyReader m r

type Rep (ManyReader m r a)

type Rep (ManyReader m r a) = D1 (MetaData "ManyReader" "Parameterized.Control.Monad.Trans.Reader" "parameterized-0.4.0.0-H8NmV43vqoy2pwNNNesLX0" True) (C1 (MetaCons "ManyReader" PrefixI True) (S1 (MetaSel (Just Symbol "runManyReader") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ReaderT * r m a))))