Copyright	(c) Brent Yorgey 2016
License	BSD3 (see LICENSE)
Maintainer	byorgey@gmail.com
Stability	experimental
Portability	non-portable (multi-param classes, functional dependencies, undecidable instances)
Safe Haskell	Safe
Language	Haskell2010

Control.Monad.Random.Strict

Contents

The Rand monad transformer
The RandT monad transformer
Some convenience re-exports

Description

Random monads that are strict in the generator state. For a lazy version, see Control.Monad.Random.Lazy, which has the same interface.

Synopsis

type Rand g = RandT g Identity
liftRand :: (g -> (a, g)) -> Rand g a
runRand :: Rand g a -> g -> (a, g)
evalRand :: Rand g a -> g -> a
execRand :: Rand g a -> g -> g
mapRand :: ((a, g) -> (b, g)) -> Rand g a -> Rand g b
withRand :: (g -> g) -> Rand g a -> Rand g a
evalRandIO :: Rand StdGen a -> IO a
data RandT g (m :: Type -> Type) a
liftRandT :: (g -> m (a, g)) -> RandT g m a
runRandT :: RandT g m a -> g -> m (a, g)
evalRandT :: Monad m => RandT g m a -> g -> m a
execRandT :: Monad m => RandT g m a -> g -> m g
mapRandT :: (m (a, g) -> n (b, g)) -> RandT g m a -> RandT g n b
withRandT :: forall g (m :: Type -> Type) a. (g -> g) -> RandT g m a -> RandT g m a
evalRandTIO :: MonadIO m => RandT StdGen m a -> m a
class Random a where
- randomR :: RandomGen g => (a, a) -> g -> (a, g)
- random :: RandomGen g => g -> (a, g)
- randomRs :: RandomGen g => (a, a) -> g -> [a]
- randoms :: RandomGen g => g -> [a]
class Uniform a
class Finite a
class UniformRange a
data StdGen
class RandomGen g where
- next :: g -> (Int, g)
- genWord8 :: g -> (Word8, g)
- genWord16 :: g -> (Word16, g)
- genWord32 :: g -> (Word32, g)
- genWord64 :: g -> (Word64, g)
- genWord32R :: Word32 -> g -> (Word32, g)
- genWord64R :: Word64 -> g -> (Word64, g)
- genShortByteString :: Int -> g -> (ShortByteString, g)
- genRange :: g -> (Int, Int)
- split :: g -> (g, g)
mkStdGen :: Int -> StdGen
genByteString :: RandomGen g => Int -> g -> (ByteString, g)
initStdGen :: MonadIO m => m StdGen
setStdGen :: MonadIO m => StdGen -> m ()
getStdGen :: MonadIO m => m StdGen
newStdGen :: MonadIO m => m StdGen
getStdRandom :: MonadIO m => (StdGen -> (a, StdGen)) -> m a
randomRIO :: (Random a, MonadIO m) => (a, a) -> m a
randomIO :: (Random a, MonadIO m) => m a
module Control.Monad.Random.Class
class Functor (f :: Type -> Type) where
- fmap :: (a -> b) -> f a -> f b
- (<$) :: a -> f b -> f a
class Applicative m => Monad (m :: Type -> Type) where
- (>>=) :: m a -> (a -> m b) -> m b
- (>>) :: m a -> m b -> m b
- return :: a -> m a
join :: Monad m => m (m a) -> m a
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- mzero :: m a
- mplus :: m a -> m a -> m a
(=<<) :: Monad m => (a -> m b) -> m a -> m b
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
ap :: Monad m => m (a -> b) -> m a -> m b
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
when :: Applicative f => Bool -> f () -> f ()
(<$!>) :: Monad m => (a -> b) -> m a -> m b
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
forever :: Applicative f => f a -> f b
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
replicateM :: Applicative m => Int -> m a -> m [a]
replicateM_ :: Applicative m => Int -> m a -> m ()
unless :: Applicative f => Bool -> f () -> f ()
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
void :: Functor f => f a -> f ()
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
guard :: Alternative f => Bool -> f ()
class Monad m => MonadFail (m :: Type -> Type) where
- fail :: String -> m a
class Monad m => MonadFix (m :: Type -> Type) where
- mfix :: (a -> m a) -> m a
fix :: (a -> a) -> a
class (forall (m :: Type -> Type). Monad m => Monad (t m)) => MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- lift :: Monad m => m a -> t m a
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a

The Rand monad transformer

type Rand g = RandT g Identity Source #

A random monad parameterized by the type g of the generator to carry.

The return function leaves the generator unchanged, while >>= uses the final generator of the first computation as the initial generator of the second.

liftRand Source #

Arguments

:: (g -> (a, g))	pure random transformer
-> Rand g a	equivalent generator-passing computation

Construct a random monad computation from a function. (The inverse of runRand.)

runRand Source #

Arguments

:: Rand g a	generator-passing computation to execute
-> g	initial generator
-> (a, g)	return value and final generator

Unwrap a random monad computation as a function. (The inverse of liftRand.)

evalRand Source #

Arguments

:: Rand g a	generator-passing computation to execute
-> g	initial generator
-> a	return value of the random computation

Evaluate a random computation with the given initial generator and return the final value, discarding the final generator.

```
evalRand m s = fst (runRand m s)
```

execRand Source #

Arguments

:: Rand g a	generator-passing computation to execute
-> g	initial generator
-> g	final generator

Evaluate a random computation with the given initial generator and return the final generator, discarding the final value.

```
execRand m s = snd (runRand m s)
```

mapRand :: ((a, g) -> (b, g)) -> Rand g a -> Rand g b Source #

Map both the return value and final generator of a computation using the given function.

```
runRand (mapRand f m) = f . runRand m
```

withRand :: (g -> g) -> Rand g a -> Rand g a Source #

withRand f m executes action m on a generator modified by applying f.

```
withRand f m = modify f >> m
```

evalRandIO :: Rand StdGen a -> IO a Source #

Evaluate a random computation in the IO monad, splitting the global standard generator to get a new one for the computation.

The RandT monad transformer

data RandT g (m :: Type -> Type) a Source #

A random transformer monad parameterized by:

g - The generator.
m - The inner monad.

The return function leaves the generator unchanged, while >>= uses the final generator of the first computation as the initial generator of the second.

Instances

Instances details

(MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

(RandomGen g, Monad m) => MonadSplit g (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

getSplit :: RandT g m g Source #

MonadError e m => MonadError e (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

throwError :: e -> RandT g m a

catchError :: RandT g m a -> (e -> RandT g m a) -> RandT g m a

MonadReader r m => MonadReader r (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

ask :: RandT g m r

local :: (r -> r) -> RandT g m a -> RandT g m a

reader :: (r -> a) -> RandT g m a

MonadState s m => MonadState s (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

get :: RandT g m s

put :: s -> RandT g m ()

state :: (s -> (a, s)) -> RandT g m a

MonadWriter w m => MonadWriter w (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

writer :: (a, w) -> RandT g m a

tell :: w -> RandT g m ()

listen :: RandT g m a -> RandT g m (a, w)

pass :: RandT g m (a, w -> w) -> RandT g m a

MonadTrans (RandT g) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

lift :: Monad m => m a -> RandT g m a #

(Monad m, RandomGen g) => RandomGenM (RandGen g) g (RandT g m) Source #

Since: 0.5.3

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

applyRandomGenM :: (g -> (a, g)) -> RandGen g -> RandT g m a Source #

(Monad m, RandomGen g) => StatefulGen (RandGen g) (RandT g m) Source #

Since: 0.5.3

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

uniformWord32R :: Word32 -> RandGen g -> RandT g m Word32 Source #

uniformWord64R :: Word64 -> RandGen g -> RandT g m Word64 Source #

uniformWord8 :: RandGen g -> RandT g m Word8 Source #

uniformWord16 :: RandGen g -> RandT g m Word16 Source #

uniformWord32 :: RandGen g -> RandT g m Word32 Source #

uniformWord64 :: RandGen g -> RandT g m Word64 Source #

uniformShortByteString :: Int -> RandGen g -> RandT g m ShortByteString Source #

(Monad m, RandomGen g) => MonadInterleave (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

interleave :: RandT g m a -> RandT g m a Source #

(RandomGen g, Monad m) => MonadRandom (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

getRandomR :: Random a => (a, a) -> RandT g m a Source #

getRandom :: Random a => RandT g m a Source #

getRandomRs :: Random a => (a, a) -> RandT g m [a] Source #

getRandoms :: Random a => RandT g m [a] Source #

MonadIO m => MonadIO (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

liftIO :: IO a -> RandT g m a #

MonadPlus m => Alternative (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

empty :: RandT g m a

(<|>) :: RandT g m a -> RandT g m a -> RandT g m a

some :: RandT g m a -> RandT g m [a]

many :: RandT g m a -> RandT g m [a]

Monad m => Applicative (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

pure :: a -> RandT g m a

(<*>) :: RandT g m (a -> b) -> RandT g m a -> RandT g m b

liftA2 :: (a -> b -> c) -> RandT g m a -> RandT g m b -> RandT g m c

(*>) :: RandT g m a -> RandT g m b -> RandT g m b

(<*) :: RandT g m a -> RandT g m b -> RandT g m a

Functor m => Functor (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

fmap :: (a -> b) -> RandT g m a -> RandT g m b #

(<$) :: a -> RandT g m b -> RandT g m a #

Monad m => Monad (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

(>>=) :: RandT g m a -> (a -> RandT g m b) -> RandT g m b #

(>>) :: RandT g m a -> RandT g m b -> RandT g m b #

return :: a -> RandT g m a #

MonadPlus m => MonadPlus (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

mzero :: RandT g m a #

mplus :: RandT g m a -> RandT g m a -> RandT g m a #

MonadFail m => MonadFail (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

fail :: String -> RandT g m a #

MonadFix m => MonadFix (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

mfix :: (a -> RandT g m a) -> RandT g m a #

MonadCont m => MonadCont (RandT g m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Methods

callCC :: ((a -> RandT g m b) -> RandT g m a) -> RandT g m a

PrimMonad m => PrimMonad (RandT s m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

Associated Types

type PrimState (RandT s m)
Instance details Defined in Control.Monad.Trans.Random.Strict type PrimState (RandT s m) = PrimState m

Methods

primitive :: (State# (PrimState (RandT s m)) -> (# State# (PrimState (RandT s m)), a #)) -> RandT s m a Source #

type PrimState (RandT s m) Source #

Instance details

Defined in Control.Monad.Trans.Random.Strict

type PrimState (RandT s m) = PrimState m

liftRandT Source #

Arguments

:: (g -> m (a, g))	impure random transformer
-> RandT g m a	equivalent generator-passing computation

Construct a random monad computation from an impure function. (The inverse of runRandT.)

runRandT Source #

Arguments

:: RandT g m a	generator-passing computation to execute
-> g	initial generator
-> m (a, g)	return value and final generator

Unwrap a random monad computation as an impure function. (The inverse of liftRandT.)

evalRandT :: Monad m => RandT g m a -> g -> m a Source #

Evaluate a random computation with the given initial generator and return the final value, discarding the final generator.

evalRandT m g = liftM fst (runRandT m g)

execRandT :: Monad m => RandT g m a -> g -> m g Source #

Evaluate a random computation with the given initial generator and return the final generator, discarding the final value.

execRandT m g = liftM snd (runRandT m g)

mapRandT :: (m (a, g) -> n (b, g)) -> RandT g m a -> RandT g n b Source #

Map both the return value and final generator of a computation using the given function.

runRandT (mapRandT f m) = f . runRandT m

withRandT :: forall g (m :: Type -> Type) a. (g -> g) -> RandT g m a -> RandT g m a Source #

withRandT f m executes action m on a generator modified by applying f.

```
withRandT f m = modify f >> m
```

evalRandTIO :: MonadIO m => RandT StdGen m a -> m a Source #

Evaluate a random computation that is embedded in the IO monad, splitting the global standard generator to get a new one for the computation.

Some convenience re-exports

class Random a where Source #

The class of types for which random values can be generated. Most instances of Random will produce values that are uniformly distributed on the full range, but for those types without a well-defined "full range" some sensible default subrange will be selected.

Random exists primarily for backwards compatibility with version 1.1 of this library. In new code, use the better specified Uniform and UniformRange instead.

Since: random-1.0.0

Minimal complete definition

Nothing

Methods

randomR :: RandomGen g => (a, a) -> g -> (a, g) Source #

Takes a range (lo,hi) and a pseudo-random number generator g, and returns a pseudo-random value uniformly distributed over the closed interval [lo,hi], together with a new generator. It is unspecified what happens if lo>hi, but usually the values will simply get swapped.

>>> let gen = mkStdGen 2021
>>> fst $ randomR ('a', 'z') gen
't'
>>> fst $ randomR ('z', 'a') gen
't'

For continuous types there is no requirement that the values lo and hi are ever produced, but they may be, depending on the implementation and the interval.

There is no requirement to follow the Ord instance and the concept of range can be defined on per type basis. For example product types will treat their values independently:

>>> fst $ randomR (('a', 5.0), ('z', 10.0)) $ mkStdGen 2021
('t',6.240232662366563)

In case when a lawful range is desired uniformR should be used instead.

Since: random-1.0.0

default randomR :: (RandomGen g, UniformRange a) => (a, a) -> g -> (a, g) Source #

random :: RandomGen g => g -> (a, g) Source #

The same as randomR, but using a default range determined by the type:

For bounded types (instances of Bounded, such as Char), the range is normally the whole type.
For floating point types, the range is normally the closed interval [0,1].
For Integer, the range is (arbitrarily) the range of Int.

Since: random-1.0.0

default random :: (RandomGen g, Uniform a) => g -> (a, g) Source #

randomRs :: RandomGen g => (a, a) -> g -> [a] Source #

Plural variant of randomR, producing an infinite list of pseudo-random values instead of returning a new generator.

Since: random-1.0.0

randoms :: RandomGen g => g -> [a] Source #

Plural variant of random, producing an infinite list of pseudo-random values instead of returning a new generator.

Since: random-1.0.0

Instances

Instances details

Random CBool
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CBool, CBool) -> g -> (CBool, g) Source # random :: RandomGen g => g -> (CBool, g) Source # randomRs :: RandomGen g => (CBool, CBool) -> g -> [CBool] Source # randoms :: RandomGen g => g -> [CBool] Source #
Random CChar
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CChar, CChar) -> g -> (CChar, g) Source # random :: RandomGen g => g -> (CChar, g) Source # randomRs :: RandomGen g => (CChar, CChar) -> g -> [CChar] Source # randoms :: RandomGen g => g -> [CChar] Source #
Random CDouble	Note - `random` produces values in the closed range `[0,1]`.
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CDouble, CDouble) -> g -> (CDouble, g) Source # random :: RandomGen g => g -> (CDouble, g) Source # randomRs :: RandomGen g => (CDouble, CDouble) -> g -> [CDouble] Source # randoms :: RandomGen g => g -> [CDouble] Source #
Random CFloat	Note - `random` produces values in the closed range `[0,1]`.
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CFloat, CFloat) -> g -> (CFloat, g) Source # random :: RandomGen g => g -> (CFloat, g) Source # randomRs :: RandomGen g => (CFloat, CFloat) -> g -> [CFloat] Source # randoms :: RandomGen g => g -> [CFloat] Source #
Random CInt
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CInt, CInt) -> g -> (CInt, g) Source # random :: RandomGen g => g -> (CInt, g) Source # randomRs :: RandomGen g => (CInt, CInt) -> g -> [CInt] Source # randoms :: RandomGen g => g -> [CInt] Source #
Random CIntMax
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CIntMax, CIntMax) -> g -> (CIntMax, g) Source # random :: RandomGen g => g -> (CIntMax, g) Source # randomRs :: RandomGen g => (CIntMax, CIntMax) -> g -> [CIntMax] Source # randoms :: RandomGen g => g -> [CIntMax] Source #
Random CIntPtr
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CIntPtr, CIntPtr) -> g -> (CIntPtr, g) Source # random :: RandomGen g => g -> (CIntPtr, g) Source # randomRs :: RandomGen g => (CIntPtr, CIntPtr) -> g -> [CIntPtr] Source # randoms :: RandomGen g => g -> [CIntPtr] Source #
Random CLLong
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CLLong, CLLong) -> g -> (CLLong, g) Source # random :: RandomGen g => g -> (CLLong, g) Source # randomRs :: RandomGen g => (CLLong, CLLong) -> g -> [CLLong] Source # randoms :: RandomGen g => g -> [CLLong] Source #
Random CLong
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CLong, CLong) -> g -> (CLong, g) Source # random :: RandomGen g => g -> (CLong, g) Source # randomRs :: RandomGen g => (CLong, CLong) -> g -> [CLong] Source # randoms :: RandomGen g => g -> [CLong] Source #
Random CPtrdiff
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CPtrdiff, CPtrdiff) -> g -> (CPtrdiff, g) Source # random :: RandomGen g => g -> (CPtrdiff, g) Source # randomRs :: RandomGen g => (CPtrdiff, CPtrdiff) -> g -> [CPtrdiff] Source # randoms :: RandomGen g => g -> [CPtrdiff] Source #
Random CSChar
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CSChar, CSChar) -> g -> (CSChar, g) Source # random :: RandomGen g => g -> (CSChar, g) Source # randomRs :: RandomGen g => (CSChar, CSChar) -> g -> [CSChar] Source # randoms :: RandomGen g => g -> [CSChar] Source #
Random CShort
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CShort, CShort) -> g -> (CShort, g) Source # random :: RandomGen g => g -> (CShort, g) Source # randomRs :: RandomGen g => (CShort, CShort) -> g -> [CShort] Source # randoms :: RandomGen g => g -> [CShort] Source #
Random CSigAtomic
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CSigAtomic, CSigAtomic) -> g -> (CSigAtomic, g) Source # random :: RandomGen g => g -> (CSigAtomic, g) Source # randomRs :: RandomGen g => (CSigAtomic, CSigAtomic) -> g -> [CSigAtomic] Source # randoms :: RandomGen g => g -> [CSigAtomic] Source #
Random CSize
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CSize, CSize) -> g -> (CSize, g) Source # random :: RandomGen g => g -> (CSize, g) Source # randomRs :: RandomGen g => (CSize, CSize) -> g -> [CSize] Source # randoms :: RandomGen g => g -> [CSize] Source #
Random CUChar
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CUChar, CUChar) -> g -> (CUChar, g) Source # random :: RandomGen g => g -> (CUChar, g) Source # randomRs :: RandomGen g => (CUChar, CUChar) -> g -> [CUChar] Source # randoms :: RandomGen g => g -> [CUChar] Source #
Random CUInt
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CUInt, CUInt) -> g -> (CUInt, g) Source # random :: RandomGen g => g -> (CUInt, g) Source # randomRs :: RandomGen g => (CUInt, CUInt) -> g -> [CUInt] Source # randoms :: RandomGen g => g -> [CUInt] Source #
Random CUIntMax
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CUIntMax, CUIntMax) -> g -> (CUIntMax, g) Source # random :: RandomGen g => g -> (CUIntMax, g) Source # randomRs :: RandomGen g => (CUIntMax, CUIntMax) -> g -> [CUIntMax] Source # randoms :: RandomGen g => g -> [CUIntMax] Source #
Random CUIntPtr
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CUIntPtr, CUIntPtr) -> g -> (CUIntPtr, g) Source # random :: RandomGen g => g -> (CUIntPtr, g) Source # randomRs :: RandomGen g => (CUIntPtr, CUIntPtr) -> g -> [CUIntPtr] Source # randoms :: RandomGen g => g -> [CUIntPtr] Source #
Random CULLong
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CULLong, CULLong) -> g -> (CULLong, g) Source # random :: RandomGen g => g -> (CULLong, g) Source # randomRs :: RandomGen g => (CULLong, CULLong) -> g -> [CULLong] Source # randoms :: RandomGen g => g -> [CULLong] Source #
Random CULong
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CULong, CULong) -> g -> (CULong, g) Source # random :: RandomGen g => g -> (CULong, g) Source # randomRs :: RandomGen g => (CULong, CULong) -> g -> [CULong] Source # randoms :: RandomGen g => g -> [CULong] Source #
Random CUShort
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CUShort, CUShort) -> g -> (CUShort, g) Source # random :: RandomGen g => g -> (CUShort, g) Source # randomRs :: RandomGen g => (CUShort, CUShort) -> g -> [CUShort] Source # randoms :: RandomGen g => g -> [CUShort] Source #
Random CWchar
Instance details Defined in System.Random Methods randomR :: RandomGen g => (CWchar, CWchar) -> g -> (CWchar, g) Source # random :: RandomGen g => g -> (CWchar, g) Source # randomRs :: RandomGen g => (CWchar, CWchar) -> g -> [CWchar] Source # randoms :: RandomGen g => g -> [CWchar] Source #
Random Int16
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Int16, Int16) -> g -> (Int16, g) Source # random :: RandomGen g => g -> (Int16, g) Source # randomRs :: RandomGen g => (Int16, Int16) -> g -> [Int16] Source # randoms :: RandomGen g => g -> [Int16] Source #
Random Int32
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Int32, Int32) -> g -> (Int32, g) Source # random :: RandomGen g => g -> (Int32, g) Source # randomRs :: RandomGen g => (Int32, Int32) -> g -> [Int32] Source # randoms :: RandomGen g => g -> [Int32] Source #
Random Int64
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Int64, Int64) -> g -> (Int64, g) Source # random :: RandomGen g => g -> (Int64, g) Source # randomRs :: RandomGen g => (Int64, Int64) -> g -> [Int64] Source # randoms :: RandomGen g => g -> [Int64] Source #
Random Int8
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Int8, Int8) -> g -> (Int8, g) Source # random :: RandomGen g => g -> (Int8, g) Source # randomRs :: RandomGen g => (Int8, Int8) -> g -> [Int8] Source # randoms :: RandomGen g => g -> [Int8] Source #
Random Word16
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Word16, Word16) -> g -> (Word16, g) Source # random :: RandomGen g => g -> (Word16, g) Source # randomRs :: RandomGen g => (Word16, Word16) -> g -> [Word16] Source # randoms :: RandomGen g => g -> [Word16] Source #
Random Word32
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Word32, Word32) -> g -> (Word32, g) Source # random :: RandomGen g => g -> (Word32, g) Source # randomRs :: RandomGen g => (Word32, Word32) -> g -> [Word32] Source # randoms :: RandomGen g => g -> [Word32] Source #
Random Word64
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Word64, Word64) -> g -> (Word64, g) Source # random :: RandomGen g => g -> (Word64, g) Source # randomRs :: RandomGen g => (Word64, Word64) -> g -> [Word64] Source # randoms :: RandomGen g => g -> [Word64] Source #
Random Word8
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Word8, Word8) -> g -> (Word8, g) Source # random :: RandomGen g => g -> (Word8, g) Source # randomRs :: RandomGen g => (Word8, Word8) -> g -> [Word8] Source # randoms :: RandomGen g => g -> [Word8] Source #
Random Integer	Note - `random` generates values in the `Int` range
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Integer, Integer) -> g -> (Integer, g) Source # random :: RandomGen g => g -> (Integer, g) Source # randomRs :: RandomGen g => (Integer, Integer) -> g -> [Integer] Source # randoms :: RandomGen g => g -> [Integer] Source #
Random Bool
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Bool, Bool) -> g -> (Bool, g) Source # random :: RandomGen g => g -> (Bool, g) Source # randomRs :: RandomGen g => (Bool, Bool) -> g -> [Bool] Source # randoms :: RandomGen g => g -> [Bool] Source #
Random Char
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Char, Char) -> g -> (Char, g) Source # random :: RandomGen g => g -> (Char, g) Source # randomRs :: RandomGen g => (Char, Char) -> g -> [Char] Source # randoms :: RandomGen g => g -> [Char] Source #
Random Double	Note - `random` produces values in the closed range `[0,1]`.
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Double, Double) -> g -> (Double, g) Source # random :: RandomGen g => g -> (Double, g) Source # randomRs :: RandomGen g => (Double, Double) -> g -> [Double] Source # randoms :: RandomGen g => g -> [Double] Source #
Random Float	Note - `random` produces values in the closed range `[0,1]`.
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Float, Float) -> g -> (Float, g) Source # random :: RandomGen g => g -> (Float, g) Source # randomRs :: RandomGen g => (Float, Float) -> g -> [Float] Source # randoms :: RandomGen g => g -> [Float] Source #
Random Int
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Int, Int) -> g -> (Int, g) Source # random :: RandomGen g => g -> (Int, g) Source # randomRs :: RandomGen g => (Int, Int) -> g -> [Int] Source # randoms :: RandomGen g => g -> [Int] Source #
Random Word
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Word, Word) -> g -> (Word, g) Source # random :: RandomGen g => g -> (Word, g) Source # randomRs :: RandomGen g => (Word, Word) -> g -> [Word] Source # randoms :: RandomGen g => g -> [Word] Source #
(Random a, Random b) => Random (a, b)	Note - `randomR` treats `a` and `b` types independently
Instance details Defined in System.Random Methods randomR :: RandomGen g => ((a, b), (a, b)) -> g -> ((a, b), g) Source # random :: RandomGen g => g -> ((a, b), g) Source # randomRs :: RandomGen g => ((a, b), (a, b)) -> g -> [(a, b)] Source # randoms :: RandomGen g => g -> [(a, b)] Source #
(Random a, Random b, Random c) => Random (a, b, c)	Note - `randomR` treats `a`, `b` and `c` types independently
Instance details Defined in System.Random Methods randomR :: RandomGen g => ((a, b, c), (a, b, c)) -> g -> ((a, b, c), g) Source # random :: RandomGen g => g -> ((a, b, c), g) Source # randomRs :: RandomGen g => ((a, b, c), (a, b, c)) -> g -> [(a, b, c)] Source # randoms :: RandomGen g => g -> [(a, b, c)] Source #
(Random a, Random b, Random c, Random d) => Random (a, b, c, d)	Note - `randomR` treats `a`, `b`, `c` and `d` types independently
Instance details Defined in System.Random Methods randomR :: RandomGen g => ((a, b, c, d), (a, b, c, d)) -> g -> ((a, b, c, d), g) Source # random :: RandomGen g => g -> ((a, b, c, d), g) Source # randomRs :: RandomGen g => ((a, b, c, d), (a, b, c, d)) -> g -> [(a, b, c, d)] Source # randoms :: RandomGen g => g -> [(a, b, c, d)] Source #
(Random a, Random b, Random c, Random d, Random e) => Random (a, b, c, d, e)	Note - `randomR` treats `a`, `b`, `c`, `d` and `e` types independently
Instance details Defined in System.Random Methods randomR :: RandomGen g => ((a, b, c, d, e), (a, b, c, d, e)) -> g -> ((a, b, c, d, e), g) Source # random :: RandomGen g => g -> ((a, b, c, d, e), g) Source # randomRs :: RandomGen g => ((a, b, c, d, e), (a, b, c, d, e)) -> g -> [(a, b, c, d, e)] Source # randoms :: RandomGen g => g -> [(a, b, c, d, e)] Source #
(Random a, Random b, Random c, Random d, Random e, Random f) => Random (a, b, c, d, e, f)	Note - `randomR` treats `a`, `b`, `c`, `d`, `e` and `f` types independently
Instance details Defined in System.Random Methods randomR :: RandomGen g => ((a, b, c, d, e, f), (a, b, c, d, e, f)) -> g -> ((a, b, c, d, e, f), g) Source # random :: RandomGen g => g -> ((a, b, c, d, e, f), g) Source # randomRs :: RandomGen g => ((a, b, c, d, e, f), (a, b, c, d, e, f)) -> g -> [(a, b, c, d, e, f)] Source # randoms :: RandomGen g => g -> [(a, b, c, d, e, f)] Source #
(Random a, Random b, Random c, Random d, Random e, Random f, Random g) => Random (a, b, c, d, e, f, g)	Note - `randomR` treats `a`, `b`, `c`, `d`, `e`, `f` and `g` types independently
Instance details Defined in System.Random Methods randomR :: RandomGen g0 => ((a, b, c, d, e, f, g), (a, b, c, d, e, f, g)) -> g0 -> ((a, b, c, d, e, f, g), g0) Source # random :: RandomGen g0 => g0 -> ((a, b, c, d, e, f, g), g0) Source # randomRs :: RandomGen g0 => ((a, b, c, d, e, f, g), (a, b, c, d, e, f, g)) -> g0 -> [(a, b, c, d, e, f, g)] Source # randoms :: RandomGen g0 => g0 -> [(a, b, c, d, e, f, g)] Source #

class Uniform a Source #

The class of types for which a uniformly distributed value can be drawn from all possible values of the type.

Since: random-1.2.0

Instances

Instances details

Uniform CBool
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CBool Source #
Uniform CChar
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CChar Source #
Uniform CInt
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CInt Source #
Uniform CIntMax
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CIntMax Source #
Uniform CIntPtr
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CIntPtr Source #
Uniform CLLong
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CLLong Source #
Uniform CLong
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CLong Source #
Uniform CPtrdiff
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CPtrdiff Source #
Uniform CSChar
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CSChar Source #
Uniform CShort
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CShort Source #
Uniform CSigAtomic
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CSigAtomic Source #
Uniform CSize
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CSize Source #
Uniform CUChar
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CUChar Source #
Uniform CUInt
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CUInt Source #
Uniform CUIntMax
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CUIntMax Source #
Uniform CUIntPtr
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CUIntPtr Source #
Uniform CULLong
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CULLong Source #
Uniform CULong
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CULong Source #
Uniform CUShort
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CUShort Source #
Uniform CWchar
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m CWchar Source #
Uniform Int16
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int16 Source #
Uniform Int32
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int32 Source #
Uniform Int64
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int64 Source #
Uniform Int8
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int8 Source #
Uniform Word16
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word16 Source #
Uniform Word32
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word32 Source #
Uniform Word64
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word64 Source #
Uniform Word8
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word8 Source #
Uniform ()
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m () Source #
Uniform Bool
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Bool Source #
Uniform Char
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Char Source #
Uniform Int
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int Source #
Uniform Word
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word Source #
(Uniform a, Uniform b) => Uniform (a, b)
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m (a, b) Source #
(Uniform a, Uniform b, Uniform c) => Uniform (a, b, c)
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m (a, b, c) Source #
(Uniform a, Uniform b, Uniform c, Uniform d) => Uniform (a, b, c, d)
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m (a, b, c, d) Source #
(Uniform a, Uniform b, Uniform c, Uniform d, Uniform e) => Uniform (a, b, c, d, e)
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m (a, b, c, d, e) Source #
(Uniform a, Uniform b, Uniform c, Uniform d, Uniform e, Uniform f) => Uniform (a, b, c, d, e, f)
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m (a, b, c, d, e, f) Source #
(Uniform a, Uniform b, Uniform c, Uniform d, Uniform e, Uniform f, Uniform g) => Uniform (a, b, c, d, e, f, g)
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g0 m => g0 -> m (a, b, c, d, e, f, g) Source #

class Finite a Source #

A type class for data with a finite number of inhabitants. This type class is used in default implementations of Uniform.

Users are not supposed to write instances of Finite manually. There is a default implementation in terms of Generic instead.

>>> :set -XDeriveGeneric -XDeriveAnyClass
>>> import GHC.Generics (Generic)
>>> data MyBool = MyTrue | MyFalse deriving (Generic, Finite)
>>> data Action = Code MyBool | Eat (Maybe Bool) | Sleep deriving (Generic, Finite)

Instances

Instances details

Finite Void
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Void -> Cardinality toFinite :: Integer -> Void fromFinite :: Void -> Integer
Finite Int16
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Int16 -> Cardinality toFinite :: Integer -> Int16 fromFinite :: Int16 -> Integer
Finite Int32
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Int32 -> Cardinality toFinite :: Integer -> Int32 fromFinite :: Int32 -> Integer
Finite Int64
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Int64 -> Cardinality toFinite :: Integer -> Int64 fromFinite :: Int64 -> Integer
Finite Int8
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Int8 -> Cardinality toFinite :: Integer -> Int8 fromFinite :: Int8 -> Integer
Finite Word16
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Word16 -> Cardinality toFinite :: Integer -> Word16 fromFinite :: Word16 -> Integer
Finite Word32
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Word32 -> Cardinality toFinite :: Integer -> Word32 fromFinite :: Word32 -> Integer
Finite Word64
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Word64 -> Cardinality toFinite :: Integer -> Word64 fromFinite :: Word64 -> Integer
Finite Word8
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Word8 -> Cardinality toFinite :: Integer -> Word8 fromFinite :: Word8 -> Integer
Finite Ordering
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Ordering -> Cardinality toFinite :: Integer -> Ordering fromFinite :: Ordering -> Integer
Finite ()
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# () -> Cardinality toFinite :: Integer -> () fromFinite :: () -> Integer
Finite Bool
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Bool -> Cardinality toFinite :: Integer -> Bool fromFinite :: Bool -> Integer
Finite Char
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Char -> Cardinality toFinite :: Integer -> Char fromFinite :: Char -> Integer
Finite Int
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Int -> Cardinality toFinite :: Integer -> Int fromFinite :: Int -> Integer
Finite Word
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# Word -> Cardinality toFinite :: Integer -> Word fromFinite :: Word -> Integer
Finite a => Finite (Maybe a)
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# (Maybe a) -> Cardinality toFinite :: Integer -> Maybe a fromFinite :: Maybe a -> Integer
(Finite a, Finite b) => Finite (Either a b)
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# (Either a b) -> Cardinality toFinite :: Integer -> Either a b fromFinite :: Either a b -> Integer
(Finite a, Finite b) => Finite (a, b)
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# (a, b) -> Cardinality toFinite :: Integer -> (a, b) fromFinite :: (a, b) -> Integer
(Finite a, Finite b, Finite c) => Finite (a, b, c)
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# (a, b, c) -> Cardinality toFinite :: Integer -> (a, b, c) fromFinite :: (a, b, c) -> Integer
(Finite a, Finite b, Finite c, Finite d) => Finite (a, b, c, d)
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# (a, b, c, d) -> Cardinality toFinite :: Integer -> (a, b, c, d) fromFinite :: (a, b, c, d) -> Integer
(Finite a, Finite b, Finite c, Finite d, Finite e) => Finite (a, b, c, d, e)
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# (a, b, c, d, e) -> Cardinality toFinite :: Integer -> (a, b, c, d, e) fromFinite :: (a, b, c, d, e) -> Integer
(Finite a, Finite b, Finite c, Finite d, Finite e, Finite f) => Finite (a, b, c, d, e, f)
Instance details Defined in System.Random.GFinite Methods cardinality :: Proxy# (a, b, c, d, e, f) -> Cardinality toFinite :: Integer -> (a, b, c, d, e, f) fromFinite :: (a, b, c, d, e, f) -> Integer

class UniformRange a Source #

The class of types for which a uniformly distributed value can be drawn from a range.

Since: random-1.2.0

Minimal complete definition

uniformRM

Instances

Instances details

UniformRange CBool
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CBool, CBool) -> g -> m CBool Source #
UniformRange CChar
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CChar, CChar) -> g -> m CChar Source #
UniformRange CDouble	See Floating point number caveats.
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CDouble, CDouble) -> g -> m CDouble Source #
UniformRange CFloat	See Floating point number caveats.
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CFloat, CFloat) -> g -> m CFloat Source #
UniformRange CInt
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CInt, CInt) -> g -> m CInt Source #
UniformRange CIntMax
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CIntMax, CIntMax) -> g -> m CIntMax Source #
UniformRange CIntPtr
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CIntPtr, CIntPtr) -> g -> m CIntPtr Source #
UniformRange CLLong
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CLLong, CLLong) -> g -> m CLLong Source #
UniformRange CLong
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CLong, CLong) -> g -> m CLong Source #
UniformRange CPtrdiff
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CPtrdiff, CPtrdiff) -> g -> m CPtrdiff Source #
UniformRange CSChar
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CSChar, CSChar) -> g -> m CSChar Source #
UniformRange CShort
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CShort, CShort) -> g -> m CShort Source #
UniformRange CSigAtomic
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CSigAtomic, CSigAtomic) -> g -> m CSigAtomic Source #
UniformRange CSize
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CSize, CSize) -> g -> m CSize Source #
UniformRange CUChar
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CUChar, CUChar) -> g -> m CUChar Source #
UniformRange CUInt
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CUInt, CUInt) -> g -> m CUInt Source #
UniformRange CUIntMax
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CUIntMax, CUIntMax) -> g -> m CUIntMax Source #
UniformRange CUIntPtr
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CUIntPtr, CUIntPtr) -> g -> m CUIntPtr Source #
UniformRange CULLong
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CULLong, CULLong) -> g -> m CULLong Source #
UniformRange CULong
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CULong, CULong) -> g -> m CULong Source #
UniformRange CUShort
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CUShort, CUShort) -> g -> m CUShort Source #
UniformRange CWchar
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (CWchar, CWchar) -> g -> m CWchar Source #
UniformRange Int16
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int16, Int16) -> g -> m Int16 Source #
UniformRange Int32
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int32, Int32) -> g -> m Int32 Source #
UniformRange Int64
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int64, Int64) -> g -> m Int64 Source #
UniformRange Int8
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int8, Int8) -> g -> m Int8 Source #
UniformRange Word16
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word16, Word16) -> g -> m Word16 Source #
UniformRange Word32
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word32, Word32) -> g -> m Word32 Source #
UniformRange Word64
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word64, Word64) -> g -> m Word64 Source #
UniformRange Word8
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word8, Word8) -> g -> m Word8 Source #
UniformRange Integer
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Integer, Integer) -> g -> m Integer Source #
UniformRange Natural
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Natural, Natural) -> g -> m Natural Source #
UniformRange ()
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => ((), ()) -> g -> m () Source #
UniformRange Bool
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Bool, Bool) -> g -> m Bool Source #
UniformRange Char
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Char, Char) -> g -> m Char Source #
UniformRange Double	See Floating point number caveats.
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Double, Double) -> g -> m Double Source #
UniformRange Float	See Floating point number caveats.
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Float, Float) -> g -> m Float Source #
UniformRange Int
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int, Int) -> g -> m Int Source #
UniformRange Word
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word, Word) -> g -> m Word Source #

data StdGen Source #

The standard pseudo-random number generator.

Instances

Instances details

NFData StdGen
Instance details Defined in System.Random.Internal Methods rnf :: StdGen -> ()
Show StdGen
Instance details Defined in System.Random.Internal Methods showsPrec :: Int -> StdGen -> ShowS show :: StdGen -> String showList :: [StdGen] -> ShowS
Eq StdGen
Instance details Defined in System.Random.Internal Methods (==) :: StdGen -> StdGen -> Bool (/=) :: StdGen -> StdGen -> Bool
RandomGen StdGen
Instance details Defined in System.Random.Internal Methods next :: StdGen -> (Int, StdGen) Source # genWord8 :: StdGen -> (Word8, StdGen) Source # genWord16 :: StdGen -> (Word16, StdGen) Source # genWord32 :: StdGen -> (Word32, StdGen) Source # genWord64 :: StdGen -> (Word64, StdGen) Source # genWord32R :: Word32 -> StdGen -> (Word32, StdGen) Source # genWord64R :: Word64 -> StdGen -> (Word64, StdGen) Source # genShortByteString :: Int -> StdGen -> (ShortByteString, StdGen) Source # genRange :: StdGen -> (Int, Int) Source # split :: StdGen -> (StdGen, StdGen) Source #
MonadSplit StdGen IO Source #
Instance details Defined in Control.Monad.Random.Class Methods getSplit :: IO StdGen Source #

class RandomGen g where Source #

RandomGen is an interface to pure pseudo-random number generators.

StdGen is the standard RandomGen instance provided by this library.

Since: random-1.0.0

Minimal complete definition

split, (genWord32 | genWord64 | next, genRange)

Methods

next :: g -> (Int, g) Source #

Returns an Int that is uniformly distributed over the range returned by genRange (including both end points), and a new generator. Using next is inefficient as all operations go via Integer. See here for more details. It is thus deprecated.

Since: random-1.0.0

genWord8 :: g -> (Word8, g) Source #

Returns a Word8 that is uniformly distributed over the entire Word8 range.

Since: random-1.2.0

genWord16 :: g -> (Word16, g) Source #

Returns a Word16 that is uniformly distributed over the entire Word16 range.

Since: random-1.2.0

genWord32 :: g -> (Word32, g) Source #

Returns a Word32 that is uniformly distributed over the entire Word32 range.

Since: random-1.2.0

genWord64 :: g -> (Word64, g) Source #

Returns a Word64 that is uniformly distributed over the entire Word64 range.

Since: random-1.2.0

genWord32R :: Word32 -> g -> (Word32, g) Source #

genWord32R upperBound g returns a Word32 that is uniformly distributed over the range [0, upperBound].

Since: random-1.2.0

genWord64R :: Word64 -> g -> (Word64, g) Source #

genWord64R upperBound g returns a Word64 that is uniformly distributed over the range [0, upperBound].

Since: random-1.2.0

genShortByteString :: Int -> g -> (ShortByteString, g) Source #

genShortByteString n g returns a ShortByteString of length n filled with pseudo-random bytes.

Since: random-1.2.0

genRange :: g -> (Int, Int) Source #

Yields the range of values returned by next.

It is required that:

If (a, b) = genRange g, then a < b.
genRange must not examine its argument so the value it returns is determined only by the instance of RandomGen.

The default definition spans the full range of Int.

Since: random-1.0.0

split :: g -> (g, g) Source #

Returns two distinct pseudo-random number generators.

Implementations should take care to ensure that the resulting generators are not correlated. Some pseudo-random number generators are not splittable. In that case, the split implementation should fail with a descriptive error message.

Since: random-1.0.0

Instances

Instances details

RandomGen StdGen
Instance details Defined in System.Random.Internal Methods next :: StdGen -> (Int, StdGen) Source # genWord8 :: StdGen -> (Word8, StdGen) Source # genWord16 :: StdGen -> (Word16, StdGen) Source # genWord32 :: StdGen -> (Word32, StdGen) Source # genWord64 :: StdGen -> (Word64, StdGen) Source # genWord32R :: Word32 -> StdGen -> (Word32, StdGen) Source # genWord64R :: Word64 -> StdGen -> (Word64, StdGen) Source # genShortByteString :: Int -> StdGen -> (ShortByteString, StdGen) Source # genRange :: StdGen -> (Int, Int) Source # split :: StdGen -> (StdGen, StdGen) Source #
RandomGen SMGen
Instance details Defined in System.Random.Internal Methods next :: SMGen -> (Int, SMGen) Source # genWord8 :: SMGen -> (Word8, SMGen) Source # genWord16 :: SMGen -> (Word16, SMGen) Source # genWord32 :: SMGen -> (Word32, SMGen) Source # genWord64 :: SMGen -> (Word64, SMGen) Source # genWord32R :: Word32 -> SMGen -> (Word32, SMGen) Source # genWord64R :: Word64 -> SMGen -> (Word64, SMGen) Source # genShortByteString :: Int -> SMGen -> (ShortByteString, SMGen) Source # genRange :: SMGen -> (Int, Int) Source # split :: SMGen -> (SMGen, SMGen) Source #
RandomGen SMGen
Instance details Defined in System.Random.Internal Methods next :: SMGen -> (Int, SMGen) Source # genWord8 :: SMGen -> (Word8, SMGen) Source # genWord16 :: SMGen -> (Word16, SMGen) Source # genWord32 :: SMGen -> (Word32, SMGen) Source # genWord64 :: SMGen -> (Word64, SMGen) Source # genWord32R :: Word32 -> SMGen -> (Word32, SMGen) Source # genWord64R :: Word64 -> SMGen -> (Word64, SMGen) Source # genShortByteString :: Int -> SMGen -> (ShortByteString, SMGen) Source # genRange :: SMGen -> (Int, Int) Source # split :: SMGen -> (SMGen, SMGen) Source #
RandomGen g => RandomGen (StateGen g)
Instance details Defined in System.Random.Internal Methods next :: StateGen g -> (Int, StateGen g) Source # genWord8 :: StateGen g -> (Word8, StateGen g) Source # genWord16 :: StateGen g -> (Word16, StateGen g) Source # genWord32 :: StateGen g -> (Word32, StateGen g) Source # genWord64 :: StateGen g -> (Word64, StateGen g) Source # genWord32R :: Word32 -> StateGen g -> (Word32, StateGen g) Source # genWord64R :: Word64 -> StateGen g -> (Word64, StateGen g) Source # genShortByteString :: Int -> StateGen g -> (ShortByteString, StateGen g) Source # genRange :: StateGen g -> (Int, Int) Source # split :: StateGen g -> (StateGen g, StateGen g) Source #
RandomGen g => RandomGen (AtomicGen g)
Instance details Defined in System.Random.Stateful Methods next :: AtomicGen g -> (Int, AtomicGen g) Source # genWord8 :: AtomicGen g -> (Word8, AtomicGen g) Source # genWord16 :: AtomicGen g -> (Word16, AtomicGen g) Source # genWord32 :: AtomicGen g -> (Word32, AtomicGen g) Source # genWord64 :: AtomicGen g -> (Word64, AtomicGen g) Source # genWord32R :: Word32 -> AtomicGen g -> (Word32, AtomicGen g) Source # genWord64R :: Word64 -> AtomicGen g -> (Word64, AtomicGen g) Source # genShortByteString :: Int -> AtomicGen g -> (ShortByteString, AtomicGen g) Source # genRange :: AtomicGen g -> (Int, Int) Source # split :: AtomicGen g -> (AtomicGen g, AtomicGen g) Source #
RandomGen g => RandomGen (IOGen g)
Instance details Defined in System.Random.Stateful Methods next :: IOGen g -> (Int, IOGen g) Source # genWord8 :: IOGen g -> (Word8, IOGen g) Source # genWord16 :: IOGen g -> (Word16, IOGen g) Source # genWord32 :: IOGen g -> (Word32, IOGen g) Source # genWord64 :: IOGen g -> (Word64, IOGen g) Source # genWord32R :: Word32 -> IOGen g -> (Word32, IOGen g) Source # genWord64R :: Word64 -> IOGen g -> (Word64, IOGen g) Source # genShortByteString :: Int -> IOGen g -> (ShortByteString, IOGen g) Source # genRange :: IOGen g -> (Int, Int) Source # split :: IOGen g -> (IOGen g, IOGen g) Source #
RandomGen g => RandomGen (STGen g)
Instance details Defined in System.Random.Stateful Methods next :: STGen g -> (Int, STGen g) Source # genWord8 :: STGen g -> (Word8, STGen g) Source # genWord16 :: STGen g -> (Word16, STGen g) Source # genWord32 :: STGen g -> (Word32, STGen g) Source # genWord64 :: STGen g -> (Word64, STGen g) Source # genWord32R :: Word32 -> STGen g -> (Word32, STGen g) Source # genWord64R :: Word64 -> STGen g -> (Word64, STGen g) Source # genShortByteString :: Int -> STGen g -> (ShortByteString, STGen g) Source # genRange :: STGen g -> (Int, Int) Source # split :: STGen g -> (STGen g, STGen g) Source #
RandomGen g => RandomGen (TGen g)
Instance details Defined in System.Random.Stateful Methods next :: TGen g -> (Int, TGen g) Source # genWord8 :: TGen g -> (Word8, TGen g) Source # genWord16 :: TGen g -> (Word16, TGen g) Source # genWord32 :: TGen g -> (Word32, TGen g) Source # genWord64 :: TGen g -> (Word64, TGen g) Source # genWord32R :: Word32 -> TGen g -> (Word32, TGen g) Source # genWord64R :: Word64 -> TGen g -> (Word64, TGen g) Source # genShortByteString :: Int -> TGen g -> (ShortByteString, TGen g) Source # genRange :: TGen g -> (Int, Int) Source # split :: TGen g -> (TGen g, TGen g) Source #

mkStdGen :: Int -> StdGen Source #

Constructs a StdGen deterministically.

genByteString :: RandomGen g => Int -> g -> (ByteString, g) Source #

Generates a ByteString of the specified size using a pure pseudo-random number generator. See uniformByteStringM for the monadic version.

Examples

Expand

>>> import System.Random
>>> import Data.ByteString
>>> let pureGen = mkStdGen 137
>>> unpack . fst . genByteString 10 $ pureGen
[51,123,251,37,49,167,90,109,1,4]

Since: random-1.2.0

initStdGen :: MonadIO m => m StdGen Source #

Initialize StdGen using system entropy (i.e. /dev/urandom) when it is available, while falling back on using system time as the seed.

Since: random-1.2.1

setStdGen :: MonadIO m => StdGen -> m () Source #

Sets the global pseudo-random number generator. Overwrites the contents of globalStdGen

Since: random-1.0.0

getStdGen :: MonadIO m => m StdGen Source #

Gets the global pseudo-random number generator. Extracts the contents of globalStdGen

Since: random-1.0.0

newStdGen :: MonadIO m => m StdGen Source #

Applies split to the current global pseudo-random generator globalStdGen, updates it with one of the results, and returns the other.

Since: random-1.0.0

getStdRandom :: MonadIO m => (StdGen -> (a, StdGen)) -> m a Source #

Uses the supplied function to get a value from the current global random generator, and updates the global generator with the new generator returned by the function. For example, rollDice produces a pseudo-random integer between 1 and 6:

>>> rollDice = getStdRandom (randomR (1, 6))
>>> replicateM 10 (rollDice :: IO Int)
[5,6,6,1,1,6,4,2,4,1]

This is an outdated function and it is recommended to switch to its equivalent applyAtomicGen instead, possibly with the globalStdGen if relying on the global state is acceptable.

>>> import System.Random.Stateful
>>> rollDice = applyAtomicGen (uniformR (1, 6)) globalStdGen
>>> replicateM 10 (rollDice :: IO Int)
[4,6,1,1,4,4,3,2,1,2]

Since: random-1.0.0

randomRIO :: (Random a, MonadIO m) => (a, a) -> m a Source #

A variant of randomRM that uses the global pseudo-random number generator globalStdGen

>>> randomRIO (2020, 2100) :: IO Int
2040

Similar to randomIO, this function is equivalent to getStdRandom randomR and is included in this interface for historical reasons and backwards compatibility. It is recommended to use uniformRM instead, possibly with the globalStdGen if relying on the global state is acceptable.

>>> import System.Random.Stateful
>>> uniformRM (2020, 2100) globalStdGen :: IO Int
2079

Since: random-1.0.0

randomIO :: (Random a, MonadIO m) => m a Source #

A variant of randomM that uses the global pseudo-random number generator globalStdGen.

>>> import Data.Int
>>> randomIO :: IO Int32
-1580093805

This function is equivalent to getStdRandom random and is included in this interface for historical reasons and backwards compatibility. It is recommended to use uniformM instead, possibly with the globalStdGen if relying on the global state is acceptable.

>>> import System.Random.Stateful
>>> uniformM globalStdGen :: IO Int32
-1649127057

Since: random-1.0.0

module Control.Monad.Random.Class

class Functor (f :: Type -> Type) where #

Minimal complete definition

fmap

Methods

fmap :: (a -> b) -> f a -> f b #

(<$) :: a -> f b -> f a #

Instances

Instances details

Functor Complex
Instance details Defined in Data.Complex Methods fmap :: (a -> b) -> Complex a -> Complex b # (<$) :: a -> Complex b -> Complex a #
Functor First
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Max
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Max a -> Max b # (<$) :: a -> Max b -> Max a #
Functor Min
Instance details Defined in Data.Semigroup Methods fmap :: (a -> b) -> Min a -> Min b # (<$) :: a -> Min b -> Min a #
Functor ArgDescr
Instance details Defined in System.Console.GetOpt Methods fmap :: (a -> b) -> ArgDescr a -> ArgDescr b # (<$) :: a -> ArgDescr b -> ArgDescr a #
Functor ArgOrder
Instance details Defined in System.Console.GetOpt Methods fmap :: (a -> b) -> ArgOrder a -> ArgOrder b # (<$) :: a -> ArgOrder b -> ArgOrder a #
Functor OptDescr
Instance details Defined in System.Console.GetOpt Methods fmap :: (a -> b) -> OptDescr a -> OptDescr b # (<$) :: a -> OptDescr b -> OptDescr a #
Functor NonEmpty
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Functor Identity
Instance details Defined in GHC.Internal.Data.Functor.Identity Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
Functor First
Instance details Defined in GHC.Internal.Data.Monoid Methods fmap :: (a -> b) -> First a -> First b # (<$) :: a -> First b -> First a #
Functor Last
Instance details Defined in GHC.Internal.Data.Monoid Methods fmap :: (a -> b) -> Last a -> Last b # (<$) :: a -> Last b -> Last a #
Functor Dual
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods fmap :: (a -> b) -> Dual a -> Dual b # (<$) :: a -> Dual b -> Dual a #
Functor Product
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods fmap :: (a -> b) -> Product a -> Product b # (<$) :: a -> Product b -> Product a #
Functor Sum
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a #
Functor ZipList
Instance details Defined in GHC.Internal.Functor.ZipList Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
Functor Par1
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> Par1 a -> Par1 b # (<$) :: a -> Par1 b -> Par1 a #
Functor IO
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Functor Array
Instance details Defined in Data.Primitive.Array Methods fmap :: (a -> b) -> Array a -> Array b # (<$) :: a -> Array b -> Array a #
Functor SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods fmap :: (a -> b) -> SmallArray a -> SmallArray b # (<$) :: a -> SmallArray b -> SmallArray a #
Functor Q
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
Functor TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> TyVarBndr a -> TyVarBndr b # (<$) :: a -> TyVarBndr b -> TyVarBndr a #
Functor Maybe
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Functor Solo
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> Solo a -> Solo b # (<$) :: a -> Solo b -> Solo a #
Functor []
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> [a] -> [b] # (<$) :: a -> [b] -> [a] #
Monad m => Functor (WrappedMonad m)
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a #
Functor (Arg a)
Instance details Defined in Data.Semigroup Methods fmap :: (a0 -> b) -> Arg a a0 -> Arg a b # (<$) :: a0 -> Arg a b -> Arg a a0 #
Arrow a => Functor (ArrowMonad a)
Instance details Defined in GHC.Internal.Control.Arrow Methods fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # (<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0 #
Functor (Either a)
Instance details Defined in GHC.Internal.Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Functor (U1 :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> U1 a -> U1 b # (<$) :: a -> U1 b -> U1 a #
Functor (V1 :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a #
Functor f => Functor (Lift f)
Instance details Defined in Control.Applicative.Lift Methods fmap :: (a -> b) -> Lift f a -> Lift f b # (<$) :: a -> Lift f b -> Lift f a #
Functor m => Functor (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fmap :: (a -> b) -> MaybeT m a -> MaybeT m b # (<$) :: a -> MaybeT m b -> MaybeT m a #
Functor ((,) a)
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b) -> (a, a0) -> (a, b) # (<$) :: a0 -> (a, b) -> (a, a0) #
Functor m => Functor (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods fmap :: (a -> b) -> RandT g m a -> RandT g m b # (<$) :: a -> RandT g m b -> RandT g m a #
Functor m => Functor (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Strict Methods fmap :: (a -> b) -> RandT g m a -> RandT g m b # (<$) :: a -> RandT g m b -> RandT g m a #
Arrow a => Functor (WrappedArrow a b)
Instance details Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
Functor m => Functor (Kleisli m a)
Instance details Defined in GHC.Internal.Control.Arrow Methods fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b # (<$) :: a0 -> Kleisli m a b -> Kleisli m a a0 #
Functor (Const m :: Type -> Type)
Instance details Defined in GHC.Internal.Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
Functor f => Functor (Ap f)
Instance details Defined in GHC.Internal.Data.Monoid Methods fmap :: (a -> b) -> Ap f a -> Ap f b # (<$) :: a -> Ap f b -> Ap f a #
Functor f => Functor (Alt f)
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods fmap :: (a -> b) -> Alt f a -> Alt f b # (<$) :: a -> Alt f b -> Alt f a #
(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> Generically1 f a -> Generically1 f b # (<$) :: a -> Generically1 f b -> Generically1 f a #
Functor f => Functor (Rec1 f)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b # (<$) :: a -> Rec1 f b -> Rec1 f a #
Functor (URec (Ptr ()) :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a #
Functor (URec Char :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Functor (URec Double :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Functor (URec Float :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Functor (URec Int :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Functor (URec Word :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Functor (t m) => Functor (LiftingAccum t m)
Instance details Defined in Control.Monad.Accum Methods fmap :: (a -> b) -> LiftingAccum t m a -> LiftingAccum t m b # (<$) :: a -> LiftingAccum t m b -> LiftingAccum t m a #
Functor (t m) => Functor (LiftingSelect t m)
Instance details Defined in Control.Monad.Select Methods fmap :: (a -> b) -> LiftingSelect t m a -> LiftingSelect t m b # (<$) :: a -> LiftingSelect t m b -> LiftingSelect t m a #
Functor f => Functor (Backwards f)
Instance details Defined in Control.Applicative.Backwards Methods fmap :: (a -> b) -> Backwards f a -> Backwards f b # (<$) :: a -> Backwards f b -> Backwards f a #
Functor m => Functor (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods fmap :: (a -> b) -> AccumT w m a -> AccumT w m b # (<$) :: a -> AccumT w m b -> AccumT w m a #
Functor m => Functor (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b # (<$) :: a -> ExceptT e m b -> ExceptT e m a #
Functor m => Functor (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods fmap :: (a -> b) -> IdentityT m a -> IdentityT m b # (<$) :: a -> IdentityT m b -> IdentityT m a #
Functor m => Functor (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fmap :: (a -> b) -> ReaderT r m a -> ReaderT r m b # (<$) :: a -> ReaderT r m b -> ReaderT r m a #
Functor m => Functor (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods fmap :: (a -> b) -> SelectT r m a -> SelectT r m b # (<$) :: a -> SelectT r m b -> SelectT r m a #
Functor m => Functor (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Functor m => Functor (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
Functor m => Functor (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b # (<$) :: a -> WriterT w m b -> WriterT w m a #
Functor m => Functor (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b # (<$) :: a -> WriterT w m b -> WriterT w m a #
Functor m => Functor (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods fmap :: (a -> b) -> WriterT w m a -> WriterT w m b # (<$) :: a -> WriterT w m b -> WriterT w m a #
Functor (Constant a :: Type -> Type)
Instance details Defined in Data.Functor.Constant Methods fmap :: (a0 -> b) -> Constant a a0 -> Constant a b # (<$) :: a0 -> Constant a b -> Constant a a0 #
Functor f => Functor (Reverse f)
Instance details Defined in Data.Functor.Reverse Methods fmap :: (a -> b) -> Reverse f a -> Reverse f b # (<$) :: a -> Reverse f b -> Reverse f a #
Functor ((,,) a b)
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, a0) -> (a, b, b0) # (<$) :: a0 -> (a, b, b0) -> (a, b, a0) #
(Functor f, Functor g) => Functor (Product f g)
Instance details Defined in Data.Functor.Product Methods fmap :: (a -> b) -> Product f g a -> Product f g b # (<$) :: a -> Product f g b -> Product f g a #
(Functor f, Functor g) => Functor (Sum f g)
Instance details Defined in Data.Functor.Sum Methods fmap :: (a -> b) -> Sum f g a -> Sum f g b # (<$) :: a -> Sum f g b -> Sum f g a #
(Functor f, Functor g) => Functor (f :*: g)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> (f :: g) a -> (f :: g) b # (<$) :: a -> (f :: g) b -> (f :: g) a #
(Functor f, Functor g) => Functor (f :+: g)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b # (<$) :: a -> (f :+: g) b -> (f :+: g) a #
Functor (K1 i c :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b # (<$) :: a -> K1 i c b -> K1 i c a #
Functor (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods fmap :: (a -> b) -> ContT r m a -> ContT r m b # (<$) :: a -> ContT r m b -> ContT r m a #
Functor ((,,,) a b c)
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # (<$) :: a0 -> (a, b, c, b0) -> (a, b, c, a0) #
Functor ((->) r)
Instance details Defined in GHC.Internal.Base Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a #
(Functor f, Functor g) => Functor (Compose f g)
Instance details Defined in Data.Functor.Compose Methods fmap :: (a -> b) -> Compose f g a -> Compose f g b # (<$) :: a -> Compose f g b -> Compose f g a #
(Functor f, Functor g) => Functor (f :.: g)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b # (<$) :: a -> (f :.: g) b -> (f :.: g) a #
Functor f => Functor (M1 i c f)
Instance details Defined in GHC.Internal.Generics Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b # (<$) :: a -> M1 i c f b -> M1 i c f a #
Functor m => Functor (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b # (<$) :: a -> RWST r w s m b -> RWST r w s m a #
Functor m => Functor (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b # (<$) :: a -> RWST r w s m b -> RWST r w s m a #
Functor m => Functor (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods fmap :: (a -> b) -> RWST r w s m a -> RWST r w s m b # (<$) :: a -> RWST r w s m b -> RWST r w s m a #
Functor ((,,,,) a b c d)
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, a0) -> (a, b, c, d, b0) # (<$) :: a0 -> (a, b, c, d, b0) -> (a, b, c, d, a0) #
Functor ((,,,,,) a b c d e)
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, e, a0) -> (a, b, c, d, e, b0) # (<$) :: a0 -> (a, b, c, d, e, b0) -> (a, b, c, d, e, a0) #
Functor ((,,,,,,) a b c d e f)
Instance details Defined in GHC.Internal.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, e, f, a0) -> (a, b, c, d, e, f, b0) # (<$) :: a0 -> (a, b, c, d, e, f, b0) -> (a, b, c, d, e, f, a0) #

class Applicative m => Monad (m :: Type -> Type) where #

Minimal complete definition

(>>=)

Methods

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

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

return :: a -> m a #

Instances

Instances details

Monad Complex
Instance details Defined in Data.Complex Methods (>>=) :: Complex a -> (a -> Complex b) -> Complex b # (>>) :: Complex a -> Complex b -> Complex b # return :: a -> Complex a #
Monad First
Instance details Defined in Data.Semigroup Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a #
Monad Last
Instance details Defined in Data.Semigroup Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a #
Monad Max
Instance details Defined in Data.Semigroup Methods (>>=) :: Max a -> (a -> Max b) -> Max b # (>>) :: Max a -> Max b -> Max b # return :: a -> Max a #
Monad Min
Instance details Defined in Data.Semigroup Methods (>>=) :: Min a -> (a -> Min b) -> Min b # (>>) :: Min a -> Min b -> Min b # return :: a -> Min a #
Monad NonEmpty
Instance details Defined in GHC.Internal.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a #
Monad Identity
Instance details Defined in GHC.Internal.Data.Functor.Identity Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a #
Monad First
Instance details Defined in GHC.Internal.Data.Monoid Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a #
Monad Last
Instance details Defined in GHC.Internal.Data.Monoid Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a #
Monad Dual
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b # (>>) :: Dual a -> Dual b -> Dual b # return :: a -> Dual a #
Monad Product
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Product a -> (a -> Product b) -> Product b # (>>) :: Product a -> Product b -> Product b # return :: a -> Product a #
Monad Sum
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b # (>>) :: Sum a -> Sum b -> Sum b # return :: a -> Sum a #
Monad Par1
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b # (>>) :: Par1 a -> Par1 b -> Par1 b # return :: a -> Par1 a #
Monad IO
Instance details Defined in GHC.Internal.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a #
Monad Array
Instance details Defined in Data.Primitive.Array Methods (>>=) :: Array a -> (a -> Array b) -> Array b # (>>) :: Array a -> Array b -> Array b # return :: a -> Array a #
Monad SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods (>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b # (>>) :: SmallArray a -> SmallArray b -> SmallArray b # return :: a -> SmallArray a #
Monad Q
Instance details Defined in Language.Haskell.TH.Syntax Methods (>>=) :: Q a -> (a -> Q b) -> Q b # (>>) :: Q a -> Q b -> Q b # return :: a -> Q a #
Monad Maybe
Instance details Defined in GHC.Internal.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a #
Monad Solo
Instance details Defined in GHC.Internal.Base Methods (>>=) :: Solo a -> (a -> Solo b) -> Solo b # (>>) :: Solo a -> Solo b -> Solo b # return :: a -> Solo a #
Monad []
Instance details Defined in GHC.Internal.Base Methods (>>=) :: [a] -> (a -> [b]) -> [b] # (>>) :: [a] -> [b] -> [b] # return :: a -> [a] #
Monad m => Monad (WrappedMonad m)
Instance details Defined in Control.Applicative 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 #
ArrowApply a => Monad (ArrowMonad a)
Instance details Defined in GHC.Internal.Control.Arrow Methods (>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b # (>>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # return :: a0 -> ArrowMonad a a0 #
Monad (Either e)
Instance details Defined in GHC.Internal.Data.Either 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 #
Monad (U1 :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b # (>>) :: U1 a -> U1 b -> U1 b # return :: a -> U1 a #
Monad m => Monad (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b # (>>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # return :: a -> MaybeT m a #
Monoid a => Monad ((,) a)
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b) # (>>) :: (a, a0) -> (a, b) -> (a, b) # return :: a0 -> (a, a0) #
Monad m => Monad (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods (>>=) :: RandT g m a -> (a -> RandT g m b) -> RandT g m b # (>>) :: RandT g m a -> RandT g m b -> RandT g m b # return :: a -> RandT g m a #
Monad m => Monad (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Strict Methods (>>=) :: RandT g m a -> (a -> RandT g m b) -> RandT g m b # (>>) :: RandT g m a -> RandT g m b -> RandT g m b # return :: a -> RandT g m a #
Monad m => Monad (Kleisli m a)
Instance details Defined in GHC.Internal.Control.Arrow Methods (>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b # (>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b # return :: a0 -> Kleisli m a a0 #
Monad f => Monad (Ap f)
Instance details Defined in GHC.Internal.Data.Monoid Methods (>>=) :: Ap f a -> (a -> Ap f b) -> Ap f b # (>>) :: Ap f a -> Ap f b -> Ap f b # return :: a -> Ap f a #
Monad f => Monad (Alt f)
Instance details Defined in GHC.Internal.Data.Semigroup.Internal 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 #
Monad f => Monad (Rec1 f)
Instance details Defined in GHC.Internal.Generics 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 #
Monad (t m) => Monad (LiftingAccum t m)
Instance details Defined in Control.Monad.Accum Methods (>>=) :: LiftingAccum t m a -> (a -> LiftingAccum t m b) -> LiftingAccum t m b # (>>) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m b # return :: a -> LiftingAccum t m a #
Monad (t m) => Monad (LiftingSelect t m)
Instance details Defined in Control.Monad.Select Methods (>>=) :: LiftingSelect t m a -> (a -> LiftingSelect t m b) -> LiftingSelect t m b # (>>) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m b # return :: a -> LiftingSelect t m a #
(Monoid w, Functor m, Monad m) => Monad (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods (>>=) :: AccumT w m a -> (a -> AccumT w m b) -> AccumT w m b # (>>) :: AccumT w m a -> AccumT w m b -> AccumT w m b # return :: a -> AccumT w m a #
Monad m => Monad (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # return :: a -> ExceptT e m a #
Monad m => Monad (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods (>>=) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b # (>>) :: IdentityT m a -> IdentityT m b -> IdentityT m b # return :: a -> IdentityT m a #
Monad m => Monad (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods (>>=) :: ReaderT r m a -> (a -> ReaderT r m b) -> ReaderT r m b # (>>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b # return :: a -> ReaderT r m a #
Monad m => Monad (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods (>>=) :: SelectT r m a -> (a -> SelectT r m b) -> SelectT r m b # (>>) :: SelectT r m a -> SelectT r m b -> SelectT r m b # return :: a -> SelectT r m a #
Monad m => Monad (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a #
Monad m => Monad (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a #
Monad m => Monad (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # return :: a -> WriterT w m a #
(Monoid w, Monad m) => Monad (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # return :: a -> WriterT w m a #
(Monoid w, Monad m) => Monad (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # return :: a -> WriterT w m a #
Monad m => Monad (Reverse m)
Instance details Defined in Data.Functor.Reverse Methods (>>=) :: Reverse m a -> (a -> Reverse m b) -> Reverse m b # (>>) :: Reverse m a -> Reverse m b -> Reverse m b # return :: a -> Reverse m a #
(Monoid a, Monoid b) => Monad ((,,) a b)
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (a, b, a0) -> (a0 -> (a, b, b0)) -> (a, b, b0) # (>>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # return :: a0 -> (a, b, a0) #
(Monad f, Monad g) => Monad (Product f g)
Instance details Defined in Data.Functor.Product Methods (>>=) :: Product f g a -> (a -> Product f g b) -> Product f g b # (>>) :: Product f g a -> Product f g b -> Product f g b # return :: a -> Product f g a #
(Monad f, Monad g) => Monad (f :*: g)
Instance details Defined in GHC.Internal.Generics 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 #
Monad (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods (>>=) :: ContT r m a -> (a -> ContT r m b) -> ContT r m b # (>>) :: ContT r m a -> ContT r m b -> ContT r m b # return :: a -> ContT r m a #
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c)
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (a, b, c, a0) -> (a0 -> (a, b, c, b0)) -> (a, b, c, b0) # (>>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # return :: a0 -> (a, b, c, a0) #
Monad ((->) r)
Instance details Defined in GHC.Internal.Base Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b # (>>) :: (r -> a) -> (r -> b) -> r -> b # return :: a -> r -> a #
Monad f => Monad (M1 i c f)
Instance details Defined in GHC.Internal.Generics 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 #
Monad m => Monad (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # return :: a -> RWST r w s m a #
(Monoid w, Monad m) => Monad (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # return :: a -> RWST r w s m a #
(Monoid w, Monad m) => Monad (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # return :: a -> RWST r w s m a #

join :: Monad m => m (m a) -> m a #

liftM :: Monad m => (a1 -> r) -> m a1 -> m r #

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where #

Minimal complete definition

Nothing

Methods

mzero :: m a #

mplus :: m a -> m a -> m a #

Instances

Instances details

MonadPlus IO
Instance details Defined in GHC.Internal.Base Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
MonadPlus Array
Instance details Defined in Data.Primitive.Array Methods mzero :: Array a # mplus :: Array a -> Array a -> Array a #
MonadPlus SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods mzero :: SmallArray a # mplus :: SmallArray a -> SmallArray a -> SmallArray a #
MonadPlus Maybe
Instance details Defined in GHC.Internal.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadPlus []
Instance details Defined in GHC.Internal.Base Methods mzero :: [a] # mplus :: [a] -> [a] -> [a] #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)
Instance details Defined in GHC.Internal.Control.Arrow Methods mzero :: ArrowMonad a a0 # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 #
MonadPlus (U1 :: Type -> Type)
Instance details Defined in GHC.Internal.Generics Methods mzero :: U1 a # mplus :: U1 a -> U1 a -> U1 a #
Monad m => MonadPlus (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mzero :: MaybeT m a # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a #
MonadPlus m => MonadPlus (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods mzero :: RandT g m a # mplus :: RandT g m a -> RandT g m a -> RandT g m a #
MonadPlus m => MonadPlus (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Strict Methods mzero :: RandT g m a # mplus :: RandT g m a -> RandT g m a -> RandT g m a #
MonadPlus m => MonadPlus (Kleisli m a)
Instance details Defined in GHC.Internal.Control.Arrow Methods mzero :: Kleisli m a a0 # mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 #
MonadPlus f => MonadPlus (Ap f)
Instance details Defined in GHC.Internal.Data.Monoid Methods mzero :: Ap f a # mplus :: Ap f a -> Ap f a -> Ap f a #
MonadPlus f => MonadPlus (Alt f)
Instance details Defined in GHC.Internal.Data.Semigroup.Internal Methods mzero :: Alt f a # mplus :: Alt f a -> Alt f a -> Alt f a #
MonadPlus f => MonadPlus (Rec1 f)
Instance details Defined in GHC.Internal.Generics Methods mzero :: Rec1 f a # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a #
(Monoid w, Functor m, MonadPlus m) => MonadPlus (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods mzero :: AccumT w m a # mplus :: AccumT w m a -> AccumT w m a -> AccumT w m a #
(Monad m, Monoid e) => MonadPlus (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mzero :: ExceptT e m a # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
MonadPlus m => MonadPlus (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods mzero :: IdentityT m a # mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a #
MonadPlus m => MonadPlus (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a #
MonadPlus m => MonadPlus (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods mzero :: SelectT r m a # mplus :: SelectT r m a -> SelectT r m a -> SelectT r m a #
MonadPlus m => MonadPlus (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
MonadPlus m => MonadPlus (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
(Functor m, MonadPlus m) => MonadPlus (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
MonadPlus m => MonadPlus (Reverse m)
Instance details Defined in Data.Functor.Reverse Methods mzero :: Reverse m a # mplus :: Reverse m a -> Reverse m a -> Reverse m a #
(MonadPlus f, MonadPlus g) => MonadPlus (Product f g)
Instance details Defined in Data.Functor.Product Methods mzero :: Product f g a # mplus :: Product f g a -> Product f g a -> Product f g a #
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g)
Instance details Defined in GHC.Internal.Generics Methods mzero :: (f :: g) a # mplus :: (f :: g) a -> (f :: g) a -> (f :: g) a #
MonadPlus f => MonadPlus (M1 i c f)
Instance details Defined in GHC.Internal.Generics Methods mzero :: M1 i c f a # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a #
(Functor m, MonadPlus m) => MonadPlus (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #

(=<<) :: Monad m => (a -> m b) -> m a -> m b #

mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m () #

sequence_ :: (Foldable t, Monad m) => t (m a) -> m () #

mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b) #

sequence :: (Traversable t, Monad m) => t (m a) -> m (t a) #

ap :: Monad m => m (a -> b) -> m a -> m b #

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r #

liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r #

liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r #

liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #

when :: Applicative f => Bool -> f () -> f () #

(<$!>) :: Monad m => (a -> b) -> m a -> m b #

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c #

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c #

filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #

foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () #

forever :: Applicative f => f a -> f b #

mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a #

replicateM :: Applicative m => Int -> m a -> m [a] #

replicateM_ :: Applicative m => Int -> m a -> m () #

unless :: Applicative f => Bool -> f () -> f () #

zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #

zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #

forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m () #

msum :: (Foldable t, MonadPlus m) => t (m a) -> m a #

void :: Functor f => f a -> f () #

forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b) #

guard :: Alternative f => Bool -> f () #

class Monad m => MonadFail (m :: Type -> Type) where #

Methods

fail :: String -> m a #

Instances

Instances details

MonadFail IO
Instance details Defined in GHC.Internal.Control.Monad.Fail Methods fail :: String -> IO a #
MonadFail Array
Instance details Defined in Data.Primitive.Array Methods fail :: String -> Array a #
MonadFail SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods fail :: String -> SmallArray a #
MonadFail Q
Instance details Defined in Language.Haskell.TH.Syntax Methods fail :: String -> Q a #
MonadFail Maybe
Instance details Defined in GHC.Internal.Control.Monad.Fail Methods fail :: String -> Maybe a #
MonadFail []
Instance details Defined in GHC.Internal.Control.Monad.Fail Methods fail :: String -> [a] #
Monad m => MonadFail (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods fail :: String -> MaybeT m a #
MonadFail m => MonadFail (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods fail :: String -> RandT g m a #
MonadFail m => MonadFail (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Strict Methods fail :: String -> RandT g m a #
MonadFail f => MonadFail (Ap f)
Instance details Defined in GHC.Internal.Data.Monoid Methods fail :: String -> Ap f a #
(Monoid w, MonadFail m) => MonadFail (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods fail :: String -> AccumT w m a #
MonadFail m => MonadFail (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods fail :: String -> ExceptT e m a #
MonadFail m => MonadFail (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods fail :: String -> IdentityT m a #
MonadFail m => MonadFail (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods fail :: String -> ReaderT r m a #
MonadFail m => MonadFail (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods fail :: String -> SelectT r m a #
MonadFail m => MonadFail (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods fail :: String -> StateT s m a #
MonadFail m => MonadFail (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods fail :: String -> StateT s m a #
MonadFail m => MonadFail (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods fail :: String -> WriterT w m a #
(Monoid w, MonadFail m) => MonadFail (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods fail :: String -> WriterT w m a #
(Monoid w, MonadFail m) => MonadFail (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods fail :: String -> WriterT w m a #
MonadFail m => MonadFail (Reverse m)
Instance details Defined in Data.Functor.Reverse Methods fail :: String -> Reverse m a #
MonadFail m => MonadFail (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods fail :: String -> ContT r m a #
MonadFail m => MonadFail (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods fail :: String -> RWST r w s m a #
(Monoid w, MonadFail m) => MonadFail (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods fail :: String -> RWST r w s m a #
(Monoid w, MonadFail m) => MonadFail (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods fail :: String -> RWST r w s m a #

class Monad m => MonadFix (m :: Type -> Type) where #

Methods

mfix :: (a -> m a) -> m a #

Instances

Instances details

MonadFix Complex
Instance details Defined in Data.Complex Methods mfix :: (a -> Complex a) -> Complex a #
MonadFix First
Instance details Defined in Data.Semigroup Methods mfix :: (a -> First a) -> First a #
MonadFix Last
Instance details Defined in Data.Semigroup Methods mfix :: (a -> Last a) -> Last a #
MonadFix Max
Instance details Defined in Data.Semigroup Methods mfix :: (a -> Max a) -> Max a #
MonadFix Min
Instance details Defined in Data.Semigroup Methods mfix :: (a -> Min a) -> Min a #
MonadFix NonEmpty
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> NonEmpty a) -> NonEmpty a #
MonadFix Identity
Instance details Defined in GHC.Internal.Data.Functor.Identity Methods mfix :: (a -> Identity a) -> Identity a #
MonadFix First
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> First a) -> First a #
MonadFix Last
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Last a) -> Last a #
MonadFix Down
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Down a) -> Down a #
MonadFix Dual
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Dual a) -> Dual a #
MonadFix Product
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Product a) -> Product a #
MonadFix Sum
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Sum a) -> Sum a #
MonadFix Par1
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Par1 a) -> Par1 a #
MonadFix IO
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> IO a) -> IO a #
MonadFix Array
Instance details Defined in Data.Primitive.Array Methods mfix :: (a -> Array a) -> Array a #
MonadFix SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods mfix :: (a -> SmallArray a) -> SmallArray a #
MonadFix Q
Instance details Defined in Language.Haskell.TH.Syntax Methods mfix :: (a -> Q a) -> Q a #
MonadFix Maybe
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Maybe a) -> Maybe a #
MonadFix Solo
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Solo a) -> Solo a #
MonadFix []
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> [a]) -> [a] #
MonadFix (Either e)
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Either e a) -> Either e a #
MonadFix (ST s)
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> ST s a) -> ST s a #
MonadFix m => MonadFix (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mfix :: (a -> MaybeT m a) -> MaybeT m a #
MonadFix m => MonadFix (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods mfix :: (a -> RandT g m a) -> RandT g m a #
MonadFix m => MonadFix (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Strict Methods mfix :: (a -> RandT g m a) -> RandT g m a #
MonadFix f => MonadFix (Ap f)
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Ap f a) -> Ap f a #
MonadFix f => MonadFix (Alt f)
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Alt f a) -> Alt f a #
MonadFix f => MonadFix (Rec1 f)
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> Rec1 f a) -> Rec1 f a #
(Monoid w, Functor m, MonadFix m) => MonadFix (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods mfix :: (a -> AccumT w m a) -> AccumT w m a #
MonadFix m => MonadFix (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mfix :: (a -> ExceptT e m a) -> ExceptT e m a #
MonadFix m => MonadFix (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods mfix :: (a -> IdentityT m a) -> IdentityT m a #
MonadFix m => MonadFix (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mfix :: (a -> ReaderT r m a) -> ReaderT r m a #
MonadFix m => MonadFix (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mfix :: (a -> StateT s m a) -> StateT s m a #
MonadFix m => MonadFix (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods mfix :: (a -> StateT s m a) -> StateT s m a #
MonadFix m => MonadFix (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods mfix :: (a -> WriterT w m a) -> WriterT w m a #
(Monoid w, MonadFix m) => MonadFix (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods mfix :: (a -> WriterT w m a) -> WriterT w m a #
(Monoid w, MonadFix m) => MonadFix (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods mfix :: (a -> WriterT w m a) -> WriterT w m a #
(MonadFix f, MonadFix g) => MonadFix (Product f g)
Instance details Defined in Data.Functor.Product Methods mfix :: (a -> Product f g a) -> Product f g a #
(MonadFix f, MonadFix g) => MonadFix (f :*: g)
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> (f :: g) a) -> (f :: g) a #
MonadFix ((->) r)
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> r -> a) -> r -> a #
MonadFix f => MonadFix (M1 i c f)
Instance details Defined in GHC.Internal.Control.Monad.Fix Methods mfix :: (a -> M1 i c f a) -> M1 i c f a #
MonadFix m => MonadFix (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods mfix :: (a -> RWST r w s m a) -> RWST r w s m a #
(Monoid w, MonadFix m) => MonadFix (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods mfix :: (a -> RWST r w s m a) -> RWST r w s m a #
(Monoid w, MonadFix m) => MonadFix (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods mfix :: (a -> RWST r w s m a) -> RWST r w s m a #

fix :: (a -> a) -> a #

class (forall (m :: Type -> Type). Monad m => Monad (t m)) => MonadTrans (t :: (Type -> Type) -> Type -> Type) where #

Methods

lift :: Monad m => m a -> t m a #

Instances

Instances details

MonadTrans MaybeT
Instance details Defined in Control.Monad.Trans.Maybe Methods lift :: Monad m => m a -> MaybeT m a #
MonadTrans (RandT g) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods lift :: Monad m => m a -> RandT g m a #
MonadTrans (RandT g) Source #
Instance details Defined in Control.Monad.Trans.Random.Strict Methods lift :: Monad m => m a -> RandT g m a #
Monoid w => MonadTrans (AccumT w)
Instance details Defined in Control.Monad.Trans.Accum Methods lift :: Monad m => m a -> AccumT w m a #
MonadTrans (ExceptT e)
Instance details Defined in Control.Monad.Trans.Except Methods lift :: Monad m => m a -> ExceptT e m a #
MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Trans.Identity Methods lift :: Monad m => m a -> IdentityT m a #
MonadTrans (ReaderT r)
Instance details Defined in Control.Monad.Trans.Reader Methods lift :: Monad m => m a -> ReaderT r m a #
MonadTrans (SelectT r)
Instance details Defined in Control.Monad.Trans.Select Methods lift :: Monad m => m a -> SelectT r m a #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods lift :: Monad m => m a -> StateT s m a #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Strict Methods lift :: Monad m => m a -> StateT s m a #
MonadTrans (WriterT w)
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods lift :: Monad m => m a -> WriterT w m a #
Monoid w => MonadTrans (WriterT w)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods lift :: Monad m => m a -> WriterT w m a #
Monoid w => MonadTrans (WriterT w)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods lift :: Monad m => m a -> WriterT w m a #
MonadTrans (ContT r)
Instance details Defined in Control.Monad.Trans.Cont Methods lift :: Monad m => m a -> ContT r m a #
MonadTrans (RWST r w s)
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods lift :: Monad m => m a -> RWST r w s m a #
Monoid w => MonadTrans (RWST r w s)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods lift :: Monad m => m a -> RWST r w s m a #
Monoid w => MonadTrans (RWST r w s)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods lift :: Monad m => m a -> RWST r w s m a #

class Monad m => MonadIO (m :: Type -> Type) where #

Methods

liftIO :: IO a -> m a #

Instances

Instances details

MonadIO IO
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
MonadIO Q
Instance details Defined in Language.Haskell.TH.Syntax Methods liftIO :: IO a -> Q a #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a #
MonadIO m => MonadIO (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Lazy Methods liftIO :: IO a -> RandT g m a #
MonadIO m => MonadIO (RandT g m) Source #
Instance details Defined in Control.Monad.Trans.Random.Strict Methods liftIO :: IO a -> RandT g m a #
(Monoid w, Functor m, MonadIO m) => MonadIO (AccumT w m)
Instance details Defined in Control.Monad.Trans.Accum Methods liftIO :: IO a -> AccumT w m a #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a #
MonadIO m => MonadIO (SelectT r m)
Instance details Defined in Control.Monad.Trans.Select Methods liftIO :: IO a -> SelectT r m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a #
MonadIO m => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.CPS Methods liftIO :: IO a -> WriterT w m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods liftIO :: IO a -> WriterT w m a #
MonadIO m => MonadIO (ContT r m)
Instance details Defined in Control.Monad.Trans.Cont Methods liftIO :: IO a -> ContT r m a #
MonadIO m => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.CPS Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods liftIO :: IO a -> RWST r w s m a #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods liftIO :: IO a -> RWST r w s m a #