Safe Haskell	None
Language	Haskell2010

Control.Monad.Classes.Proxied

Description

Proxied monad. Proxied x is a monad transformer that has a global configuration parameter of type x associated with it.

It is used to implement things like ZoomT/runZoom and CustromWriterT/evalWriterWith.

Most of the time you don't need to use this directly. It is exported for two purposes:

you can use it to define new monad transformers
you can define instances for Proxied x and transformers that are based on it

Synopsis

Documentation

newtype Proxied x m a Source #

Constructors

Proxied (forall (q :: *). Reifies q x => Proxy# q -> m a)

Instances

MonadBase b m => MonadBase b (Proxied * x m) Source #
Methods liftBase :: b α -> Proxied * x m α #
MonadTrans (Proxied * x) Source #
Methods lift :: Monad m => m a -> Proxied * x m a #
MonadTransControl (Proxied * x) Source #
Associated Types type StT (Proxied * x :: (* -> ) -> -> ) a :: # Methods liftWith :: Monad m => (Run (Proxied * x) -> m a) -> Proxied * x m a # restoreT :: Monad m => m (StT (Proxied * x) a) -> Proxied * x m a #
Monad m => Monad (Proxied * x m) Source #
Methods (>>=) :: Proxied * x m a -> (a -> Proxied * x m b) -> Proxied * x m b # (>>) :: Proxied * x m a -> Proxied * x m b -> Proxied * x m b # return :: a -> Proxied * x m a # fail :: String -> Proxied * x m a #
Functor m => Functor (Proxied * x m) Source #
Methods fmap :: (a -> b) -> Proxied * x m a -> Proxied * x m b # (<$) :: a -> Proxied * x m b -> Proxied * x m a #
Applicative m => Applicative (Proxied * x m) Source #
Methods pure :: a -> Proxied * x m a # (<>) :: Proxied x m (a -> b) -> Proxied * x m a -> Proxied * x m b # liftA2 :: (a -> b -> c) -> Proxied * x m a -> Proxied * x m b -> Proxied * x m c # (>) :: Proxied x m a -> Proxied * x m b -> Proxied * x m b # (<) :: Proxied x m a -> Proxied * x m b -> Proxied * x m a #
MonadIO m => MonadIO (Proxied * x m) Source #
Methods liftIO :: IO a -> Proxied * x m a #
Alternative m => Alternative (Proxied * x m) Source #
Methods empty :: Proxied * x m a # (<\|>) :: Proxied * x m a -> Proxied * x m a -> Proxied * x m a # some :: Proxied * x m a -> Proxied * x m [a] # many :: Proxied * x m a -> Proxied * x m [a] #
MonadPlus m => MonadPlus (Proxied * x m) Source #
Methods mzero :: Proxied * x m a # mplus :: Proxied * x m a -> Proxied * x m a -> Proxied * x m a #
type StT (Proxied * x) a Source #
type StT (Proxied * x) a = a

fromProxy# :: Proxy# a -> Proxy a Source #

toProxy# :: Proxy a -> Proxy# a Source #

reify :: a -> (forall (q :: *). Reifies q a => Proxy# q -> r) -> r Source #

reflect :: Reifies q a => Proxy# q -> a Source #

class Reifies k (s :: k) a | s -> a #

Minimal complete definition

reflect

Instances

KnownNat n => Reifies Nat n Integer
Methods reflect :: proxy Integer -> a #
KnownSymbol n => Reifies Symbol n String
Methods reflect :: proxy String -> a #
Reifies * Z Int
Methods reflect :: proxy Int -> a #
Reifies * n Int => Reifies * (D n) Int
Methods reflect :: proxy Int -> a #
Reifies * n Int => Reifies * (SD n) Int
Methods reflect :: proxy Int -> a #
Reifies * n Int => Reifies * (PD n) Int
Methods reflect :: proxy Int -> a #
(B * b0, B * b1, B * b2, B * b3, B * b4, B * b5, B * b6, B * b7, (~) * w0 (W b0 b1 b2 b3), (~) * w1 (W b4 b5 b6 b7)) => Reifies * (Stable w0 w1 a) a
Methods reflect :: proxy a -> a #

data Proxy# :: forall k0. k0 -> TYPE (TupleRep ([] RuntimeRep)) #

The type constructor Proxy# is used to bear witness to some type variable. It's used when you want to pass around proxy values for doing things like modelling type applications. A Proxy# is not only unboxed, it also has a polymorphic kind, and has no runtime representation, being totally free.

proxy# :: Proxy# k0 a #

Witness for an unboxed Proxy# value, which has no runtime representation.