Control.Monad.Classes.Proxied

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

Documentation

newtype Proxied x m a

Constructors

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

Instances

MonadBase b m => MonadBase b (Proxied * x m)

Methods

liftBase :: b α -> Proxied * x m α

MonadTrans (Proxied * x)

Methods

lift :: Monad m => m a -> Proxied * x m a

MonadTransControl (Proxied * x)

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)

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)

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)

Methods

pure :: a -> Proxied * x m a

(<*>) :: Proxied * x m (a -> b) -> Proxied * x m a -> Proxied * x m b

(*>) :: 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)

Methods

liftIO :: IO a -> Proxied * x m a

Alternative m => Alternative (Proxied * x m)

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)

Methods

mzero :: Proxied * x m a

mplus :: Proxied * x m a -> Proxied * x m a -> Proxied * x m a

type StT (Proxied * x) a

type StT (Proxied * x) a = a

fromProxy# :: Proxy# a -> Proxy a

toProxy# :: Proxy a -> Proxy# a

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

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

class Reifies k s 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 k. k -> TYPE VoidRep

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# k a

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