Safe Haskell	None
Language	Haskell2010

Imj.Graphics.Render

Contents

Draw and Render
From MonadReader
Reexports

Synopsis

Draw and Render

Draw describes the ability to draw colored Chars, Strings, Texts.

Render makes the result of draw*** calls visible on the screen.

Optimized instances of Draw and Render, for games and animations drawing in the terminal, are available in Imj.Graphics.Render.Delta.Env. They minimize stdout usage using double buffering and delta rendering, thereby mitigating the screen tearing effect.

class Draw e where Source #

Minimal complete definition

drawChar', drawChars', drawTxt', drawStr'

Methods

drawChar' :: MonadIO m => e -> Char -> Coords Pos -> LayeredColor -> m () Source #

Draw a Char.

drawChars' :: MonadIO m => e -> Int -> Char -> Coords Pos -> LayeredColor -> m () Source #

Draw repeated chars.

drawTxt' :: MonadIO m => e -> Text -> Coords Pos -> LayeredColor -> m () Source #

Draw Text.

drawStr' :: MonadIO m => e -> String -> Coords Pos -> LayeredColor -> m () Source #

Draw String.

drawColorStr' :: MonadIO m => e -> ColorString -> Coords Pos -> m () Source #

Draw a ColorString.

drawAlignedTxt_' :: MonadIO m => e -> Text -> LayeredColor -> Alignment -> m () Source #

Draw text aligned w.r.t alignment and reference coordinates.

drawAlignedTxt' :: MonadIO m => e -> Text -> LayeredColor -> Alignment -> m Alignment Source #

Draws text aligned w.r.t alignment and reference coordinates.

Returns an Alignment where the reference coordinate of the input Alignment was projected on the next line.

drawAlignedColorStr' :: MonadIO m => e -> Alignment -> ColorString -> m Alignment Source #

Draw a ColorString with an Alignment constraint.

Instances

Draw NaiveDraw Source #	Direct draw to stdout : don't use for production, this is for tests only and creates heavy screen tearing.
Methods drawChar' :: MonadIO m => NaiveDraw -> Char -> Coords Pos -> LayeredColor -> m () Source # drawChars' :: MonadIO m => NaiveDraw -> Int -> Char -> Coords Pos -> LayeredColor -> m () Source # drawTxt' :: MonadIO m => NaiveDraw -> Text -> Coords Pos -> LayeredColor -> m () Source # drawStr' :: MonadIO m => NaiveDraw -> String -> Coords Pos -> LayeredColor -> m () Source # drawColorStr' :: MonadIO m => NaiveDraw -> ColorString -> Coords Pos -> m () Source # drawAlignedTxt_' :: MonadIO m => NaiveDraw -> Text -> LayeredColor -> Alignment -> m () Source # drawAlignedTxt' :: MonadIO m => NaiveDraw -> Text -> LayeredColor -> Alignment -> m Alignment Source # drawAlignedColorStr' :: MonadIO m => NaiveDraw -> Alignment -> ColorString -> m Alignment Source #
Draw DeltaEnv Source #	Draws using the delta rendering engine.
Methods drawChar' :: MonadIO m => DeltaEnv -> Char -> Coords Pos -> LayeredColor -> m () Source # drawChars' :: MonadIO m => DeltaEnv -> Int -> Char -> Coords Pos -> LayeredColor -> m () Source # drawTxt' :: MonadIO m => DeltaEnv -> Text -> Coords Pos -> LayeredColor -> m () Source # drawStr' :: MonadIO m => DeltaEnv -> String -> Coords Pos -> LayeredColor -> m () Source # drawColorStr' :: MonadIO m => DeltaEnv -> ColorString -> Coords Pos -> m () Source # drawAlignedTxt_' :: MonadIO m => DeltaEnv -> Text -> LayeredColor -> Alignment -> m () Source # drawAlignedTxt' :: MonadIO m => DeltaEnv -> Text -> LayeredColor -> Alignment -> m Alignment Source # drawAlignedColorStr' :: MonadIO m => DeltaEnv -> Alignment -> ColorString -> m Alignment Source #

class Draw e => Render e where Source #

Class describing the ability to render the result of a Draw to the screen.

It is left to the implementation to decide wether to clear the screen or not (after a renderToScreen for example), and with which color.

Minimal complete definition

renderToScreen'

Methods

renderToScreen' :: MonadIO m => e -> m () Source #

Render to the screen.

Instances

Render NaiveDraw Source #	Direct draw to stdout : don't use for production, this is for tests only and creates heavy screen tearing.
Methods renderToScreen' :: MonadIO m => NaiveDraw -> m () Source #
Render DeltaEnv Source #	Renders using the delta rendering engine.
Methods renderToScreen' :: MonadIO m => DeltaEnv -> m () Source #

From MonadReader

The functions below use Draw and Render instances in a MonadReader monad.

Hence, if you run in a MonadReader YourEnv monad (where YourEnv is your environment equiped with Draw and Render instances), you can write:

import Control.Monad.IO.Class(MonadIO)
import Control.Monad.Reader.Class(MonadReader)
import Control.Monad.Reader(runReaderT)

import Imj.Graphics.Class.Render
import Imj.Graphics.Render.FromMonadReader(drawStr, renderToScreen)

helloWorld :: (Draw e, Render e, MonadReader e m, MonadIO m) => m ()
helloWorld = drawStr "Hello World" (Coords 10 10) green >> renderToScreen

main = createEnv >>= runReaderT helloWorld

This example follows this pattern.

Draw char(s)

drawChar :: (Draw e, MonadReader e m, MonadIO m) => Char -> Coords Pos -> LayeredColor -> m () Source #

drawChars :: (Draw e, MonadReader e m, MonadIO m) => Int -> Char -> Coords Pos -> LayeredColor -> m () Source #

Draws a Char multiple times, starting at the given coordinates and then moving to the right.

Draw text

drawTxt :: (Draw e, MonadReader e m, MonadIO m) => Text -> Coords Pos -> LayeredColor -> m () Source #

drawStr :: (Draw e, MonadReader e m, MonadIO m) => String -> Coords Pos -> LayeredColor -> m () Source #

drawColorStr :: (Draw e, MonadReader e m, MonadIO m) => ColorString -> Coords Pos -> m () Source #

Draw a ColorString.

Draw aligned text

drawAlignedTxt_ :: (Draw e, MonadReader e m, MonadIO m) => Text -> LayeredColor -> Alignment -> m () Source #

Draws text with Alignment.

drawAlignedTxt :: (Draw e, MonadReader e m, MonadIO m) => Text -> LayeredColor -> Alignment -> m Alignment Source #

Draws text with Alignment.

Returns the Alignment projected on the next line.

drawAlignedColorStr :: (Draw e, MonadReader e m, MonadIO m) => Alignment -> ColorString -> m Alignment Source #

Draw a ColorString with an Alignment constraint.

Render to the physical device

renderToScreen :: (Render e, MonadReader e m, MonadIO m) => m () Source #

Render the drawing to {the screen, the console, etc...}.

Reexports

data LayeredColor Source #

A background and a foreground Color8.

Constructors

LayeredColor
Fields _colorsBackground :: !(Color8 Background) _colorsForeground :: !(Color8 Foreground)

Instances

Eq LayeredColor Source #
Methods (==) :: LayeredColor -> LayeredColor -> Bool # (/=) :: LayeredColor -> LayeredColor -> Bool #
Show LayeredColor Source #
Methods showsPrec :: Int -> LayeredColor -> ShowS # show :: LayeredColor -> String # showList :: [LayeredColor] -> ShowS #
DiscreteDistance LayeredColor Source #	First interpolate background color, then foreground color
Methods distance :: LayeredColor -> LayeredColor -> Int Source # distanceSuccessive :: Successive LayeredColor -> Int Source #
DiscreteInterpolation LayeredColor Source #	First interpolate background color, then foreground color
Methods interpolate :: LayeredColor -> LayeredColor -> Int -> LayeredColor Source # interpolateSuccessive :: Successive LayeredColor -> Int -> LayeredColor Source #

data Coords a Source #

Two-dimensional discrete coordinates. We use phantom types Pos, Vel to distinguish positions from speeds.

Constructors

Coords
Fields _coordsY :: !(Coord Row) _coordsX :: !(Coord Col)

Instances

Eq (Coords a) Source #
Methods (==) :: Coords a -> Coords a -> Bool # (/=) :: Coords a -> Coords a -> Bool #
Ord (Coords a) Source #
Methods compare :: Coords a -> Coords a -> Ordering # (<) :: Coords a -> Coords a -> Bool # (<=) :: Coords a -> Coords a -> Bool # (>) :: Coords a -> Coords a -> Bool # (>=) :: Coords a -> Coords a -> Bool # max :: Coords a -> Coords a -> Coords a # min :: Coords a -> Coords a -> Coords a #
Show (Coords a) Source #
Methods showsPrec :: Int -> Coords a -> ShowS # show :: Coords a -> String # showList :: [Coords a] -> ShowS #
DiscreteDistance (Coords Pos) Source #	Using bresenham 2d line algorithm.
Methods distance :: Coords Pos -> Coords Pos -> Int Source # distanceSuccessive :: Successive (Coords Pos) -> Int Source #
DiscreteInterpolation (Coords Pos) Source #	Using bresenham 2d line algorithm.
Methods interpolate :: Coords Pos -> Coords Pos -> Int -> Coords Pos Source # interpolateSuccessive :: Successive (Coords Pos) -> Int -> Coords Pos Source #

data Alignment Source #

Constructors

Alignment
Fields _alignmentKing :: !AlignmentKind The kind of alignment. _alignmentRef :: !(Coords Pos) The reference coordinates.

data Text :: * #

A space efficient, packed, unboxed Unicode text type.

Instances

type Item Text
type Item Text = Char

data Char :: * #

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

Instances

Bounded Char	Since: 2.1
Methods minBound :: Char # maxBound :: Char #
Enum Char	Since: 2.1
Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Eq Char
Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Data Char	Since: 4.0.0.0
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char # toConstr :: Char -> Constr # dataTypeOf :: Char -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c Char) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) # gmapT :: (forall b. Data b => b -> b) -> Char -> Char # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char #
Ord Char
Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
Read Char	Since: 2.1
Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] # readPrec :: ReadPrec Char # readListPrec :: ReadPrec [Char] #
Show Char	Since: 2.1
Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Prim Char
Methods sizeOf# :: Char -> Int# # alignment# :: Char -> Int# # indexByteArray# :: ByteArray# -> Int# -> Char # readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Char#) # writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s # setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s # indexOffAddr# :: Addr# -> Int# -> Char # readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Char#) # writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s # setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s #
Random Char
Methods randomR :: RandomGen g => (Char, Char) -> g -> (Char, g) # random :: RandomGen g => g -> (Char, g) # randomRs :: RandomGen g => (Char, Char) -> g -> [Char] # randoms :: RandomGen g => g -> [Char] # randomRIO :: (Char, Char) -> IO Char # randomIO :: IO Char #
ErrorList Char
Methods listMsg :: String -> [Char] #
Unbox Char

Vector Vector Char
Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char) # basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char) # basicLength :: Vector Char -> Int # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char # basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m () # elemseq :: Vector Char -> Char -> b -> b #
MVector MVector Char
Methods basicLength :: MVector s Char -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char # basicOverlaps :: MVector s Char -> MVector s Char -> Bool # basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char) # basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m () # basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char) # basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char # basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m () # basicClear :: PrimMonad m => MVector (PrimState m) Char -> m () # basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m () # basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m () # basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char) #
Generic1 k (URec k Char)
Associated Types type Rep1 (URec k Char) (f :: URec k Char -> ) :: k -> # Methods from1 :: f a -> Rep1 (URec k Char) f a # to1 :: Rep1 (URec k Char) f a -> f a #
IsString (Seq Char)
Methods fromString :: String -> Seq Char #
Functor (URec * Char)
Methods fmap :: (a -> b) -> URec * Char a -> URec * Char b # (<$) :: a -> URec * Char b -> URec * Char a #
Foldable (URec * Char)
Methods fold :: Monoid m => URec * Char m -> m # foldMap :: Monoid m => (a -> m) -> URec * Char a -> m # foldr :: (a -> b -> b) -> b -> URec * Char a -> b # foldr' :: (a -> b -> b) -> b -> URec * Char a -> b # foldl :: (b -> a -> b) -> b -> URec * Char a -> b # foldl' :: (b -> a -> b) -> b -> URec * Char a -> b # foldr1 :: (a -> a -> a) -> URec * Char a -> a # foldl1 :: (a -> a -> a) -> URec * Char a -> a # toList :: URec * Char a -> [a] # null :: URec * Char a -> Bool # length :: URec * Char a -> Int # elem :: Eq a => a -> URec * Char a -> Bool # maximum :: Ord a => URec * Char a -> a # minimum :: Ord a => URec * Char a -> a # sum :: Num a => URec * Char a -> a # product :: Num a => URec * Char a -> a #
Traversable (URec * Char)
Methods traverse :: Applicative f => (a -> f b) -> URec * Char a -> f (URec * Char b) # sequenceA :: Applicative f => URec * Char (f a) -> f (URec * Char a) # mapM :: Monad m => (a -> m b) -> URec * Char a -> m (URec * Char b) # sequence :: Monad m => URec * Char (m a) -> m (URec * Char a) #
Eq (URec k Char p)
Methods (==) :: URec k Char p -> URec k Char p -> Bool # (/=) :: URec k Char p -> URec k Char p -> Bool #
Ord (URec k Char p)
Methods compare :: URec k Char p -> URec k Char p -> Ordering # (<) :: URec k Char p -> URec k Char p -> Bool # (<=) :: URec k Char p -> URec k Char p -> Bool # (>) :: URec k Char p -> URec k Char p -> Bool # (>=) :: URec k Char p -> URec k Char p -> Bool # max :: URec k Char p -> URec k Char p -> URec k Char p # min :: URec k Char p -> URec k Char p -> URec k Char p #
Show (URec k Char p)
Methods showsPrec :: Int -> URec k Char p -> ShowS # show :: URec k Char p -> String # showList :: [URec k Char p] -> ShowS #
Generic (URec k Char p)
Associated Types type Rep (URec k Char p) :: * -> * # Methods from :: URec k Char p -> Rep (URec k Char p) x # to :: Rep (URec k Char p) x -> URec k Char p #
data Vector Char
data Vector Char = V_Char (Vector Char)
data URec k Char	Used for marking occurrences of `Char#` Since: 4.9.0.0
data URec k Char = UChar { uChar# :: Char# }
data MVector s Char
data MVector s Char = MV_Char (MVector s Char)
type Rep1 k (URec k Char)
type Rep1 k (URec k Char) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UChar" PrefixI True) (S1 k (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar k)))
type Rep (URec k Char p)
type Rep (URec k Char p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UChar" PrefixI True) (S1 * (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar *)))

type String = [Char] #

A String is a list of characters. String constants in Haskell are values of type String.

class Monad m => MonadIO (m :: * -> *) #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Minimal complete definition

liftIO

Instances

MonadIO IO	Since: 4.9.0.0
Methods liftIO :: IO a -> IO a #
MonadIO m => MonadIO (ListT m)
Methods liftIO :: IO a -> ListT m a #
MonadIO m => MonadIO (MaybeT m)
Methods liftIO :: IO a -> MaybeT m a #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Methods liftIO :: IO a -> ErrorT e m a #
MonadIO m => MonadIO (ExceptT e m)
Methods liftIO :: IO a -> ExceptT e m a #
MonadIO m => MonadIO (StateT s m)
Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Methods liftIO :: IO a -> StateT s m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Methods liftIO :: IO a -> WriterT w m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (IdentityT * m)
Methods liftIO :: IO a -> IdentityT * m a #
MonadIO m => MonadIO (ReaderT * r m)
Methods liftIO :: IO a -> ReaderT * r m a #
MonadIO m => MonadIO (ContT * r m)
Methods liftIO :: IO a -> ContT * r m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Methods liftIO :: IO a -> RWST r w s m a #

class Monad m => MonadReader r (m :: * -> *) | m -> r #

See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

Minimal complete definition

(ask | reader), local

Instances

MonadReader r m => MonadReader r (MaybeT m)
Methods ask :: MaybeT m r # local :: (r -> r) -> MaybeT m a -> MaybeT m a # reader :: (r -> a) -> MaybeT m a #
MonadReader r m => MonadReader r (ListT m)
Methods ask :: ListT m r # local :: (r -> r) -> ListT m a -> ListT m a # reader :: (r -> a) -> ListT m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)
Methods ask :: WriterT w m r # local :: (r -> r) -> WriterT w m a -> WriterT w m a # reader :: (r -> a) -> WriterT w m a #
MonadReader r m => MonadReader r (StateT s m)
Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadReader r m => MonadReader r (StateT s m)
Methods ask :: StateT s m r # local :: (r -> r) -> StateT s m a -> StateT s m a # reader :: (r -> a) -> StateT s m a #
MonadReader r m => MonadReader r (IdentityT * m)
Methods ask :: IdentityT * m r # local :: (r -> r) -> IdentityT * m a -> IdentityT * m a # reader :: (r -> a) -> IdentityT * m a #
MonadReader r m => MonadReader r (ExceptT e m)
Methods ask :: ExceptT e m r # local :: (r -> r) -> ExceptT e m a -> ExceptT e m a # reader :: (r -> a) -> ExceptT e m a #
(Error e, MonadReader r m) => MonadReader r (ErrorT e m)
Methods ask :: ErrorT e m r # local :: (r -> r) -> ErrorT e m a -> ErrorT e m a # reader :: (r -> a) -> ErrorT e m a #
Monad m => MonadReader r (ReaderT * r m)
Methods ask :: ReaderT * r m r # local :: (r -> r) -> ReaderT * r m a -> ReaderT * r m a # reader :: (r -> a) -> ReaderT * r m a #
MonadReader r ((->) LiftedRep LiftedRep r)
Methods ask :: (LiftedRep -> LiftedRep) r r # local :: (r -> r) -> (LiftedRep -> LiftedRep) r a -> (LiftedRep -> LiftedRep) r a # reader :: (r -> a) -> (LiftedRep -> LiftedRep) r a #
MonadReader r' m => MonadReader r' (ContT * r m)
Methods ask :: ContT * r m r' # local :: (r' -> r') -> ContT * r m a -> ContT * r m a # reader :: (r' -> a) -> ContT * r m a #
(Monad m, Monoid w) => MonadReader r (RWST r w s m)
Methods ask :: RWST r w s m r # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #
(Monad m, Monoid w) => MonadReader r (RWST r w s m)
Methods ask :: RWST r w s m r # local :: (r -> r) -> RWST r w s m a -> RWST r w s m a # reader :: (r -> a) -> RWST r w s m a #