Portability | portable |
---|---|
Stability | beta |
Maintainer | Thomas.DuBuisson@gmail.com |
Safe Haskell | None |
Much like the MonadRandom package (Control.Monad.Random), this module provides plumbing for the CryptoRandomGen generators.
- class CRandom a where
- crandom :: CryptoRandomGen g => g -> Either GenError (a, g)
- crandoms :: CryptoRandomGen g => g -> [a]
- class CRandomR a where
- crandomR :: CryptoRandomGen g => (a, a) -> g -> Either GenError (a, g)
- crandomRs :: CryptoRandomGen g => (a, a) -> g -> [a]
- class (ContainsGenError e, MonadError e m) => MonadCRandom e m where
- getCRandom :: CRandom a => m a
- getBytes :: Int -> m ByteString
- getBytesWithEntropy :: Int -> ByteString -> m ByteString
- doReseed :: ByteString -> m ()
- class (ContainsGenError e, MonadError e m) => MonadCRandomR e m where
- getCRandomR :: CRandomR a => (a, a) -> m a
- class ContainsGenError e where
- toGenError :: e -> Maybe GenError
- fromGenError :: GenError -> e
- data CRandT g e m a
- type CRand g e = CRandT g e Identity
- runCRandT :: ContainsGenError e => CRandT g e m a -> g -> m (Either e (a, g))
- evalCRandT :: (ContainsGenError e, Monad m) => CRandT g e m a -> g -> m (Either e a)
- runCRand :: CRand g GenError a -> g -> Either GenError (a, g)
- evalCRand :: CRand g GenError a -> g -> Either GenError a
- newGenCRand :: (CryptoRandomGen g, MonadCRandom GenError m, Functor m) => m g
- module Crypto.Random
Documentation
CRandom a
is much like the Random
class from the System.Random module in the random package.
The main difference is CRandom builds on crypto-api's CryptoRandomGen
, so it allows
explicit failure.
crandomR (low,high) g
as typically instantiated will generate a value between
[low, high] inclusively, swapping the pair if high < low.
Provided instances for crandom g
generates randoms between the bounds and between +/- 2^256
for Integer.
The crandomR
function has degraded (theoretically unbounded, probabilistically decent) performance
the closer your range size (high - low) is to 2^n (from the top).
crandom :: CryptoRandomGen g => g -> Either GenError (a, g)Source
crandoms :: CryptoRandomGen g => g -> [a]Source
crandomR :: CryptoRandomGen g => (a, a) -> g -> Either GenError (a, g)Source
crandomRs :: CryptoRandomGen g => (a, a) -> g -> [a]Source
class (ContainsGenError e, MonadError e m) => MonadCRandom e m whereSource
MonadCRandom m
represents a monad that can produce
random values (or fail with a GenError
). It is suggested
you use the CRandT
transformer in your monad stack.
getCRandom :: CRandom a => m aSource
getBytes :: Int -> m ByteStringSource
getBytesWithEntropy :: Int -> ByteString -> m ByteStringSource
doReseed :: ByteString -> m ()Source
MonadCRandom e m => MonadCRandom e (ReaderT r m) | |
(Monoid w, MonadCRandom e m) => MonadCRandom e (WriterT w m) | |
(Monoid w, MonadCRandom e m) => MonadCRandom e (WriterT w m) | |
MonadCRandom e m => MonadCRandom e (StateT s m) | |
MonadCRandom e m => MonadCRandom e (StateT s m) | |
(ContainsGenError e, Error e, Monad m, CryptoRandomGen g) => MonadCRandom e (CRandT g e m) | |
(Monoid w, MonadCRandom e m) => MonadCRandom e (RWST r w s m) | |
(Monoid w, MonadCRandom e m) => MonadCRandom e (RWST r w s m) |
class (ContainsGenError e, MonadError e m) => MonadCRandomR e m whereSource
getCRandomR :: CRandomR a => (a, a) -> m aSource
MonadCRandomR e m => MonadCRandomR e (ReaderT r m) | |
(MonadCRandomR e m, Monoid w) => MonadCRandomR e (WriterT w m) | |
(MonadCRandomR e m, Monoid w) => MonadCRandomR e (WriterT w m) | |
MonadCRandomR e m => MonadCRandomR e (StateT s m) | |
MonadCRandomR e m => MonadCRandomR e (StateT s m) | |
(ContainsGenError e, Error e, Monad m, CryptoRandomGen g) => MonadCRandomR e (CRandT g e m) | |
(MonadCRandomR e m, Monoid w) => MonadCRandomR e (RWST r w s m) | |
(MonadCRandomR e m, Monoid w) => MonadCRandomR e (RWST r w s m) |
class ContainsGenError e whereSource
toGenError :: e -> Maybe GenErrorSource
fromGenError :: GenError -> eSource
CRandT is the transformer suggested for MonadCRandom.
(Monad m, Error e) => MonadError e (CRandT g e m) | |
(MonadReader r m, Error e) => MonadReader r (CRandT g e m) | |
(MonadState s m, Error e) => MonadState s (CRandT g e m) | |
(MonadWriter w m, Error e) => MonadWriter w (CRandT g e m) | |
(ContainsGenError e, Error e, Monad m, CryptoRandomGen g) => MonadCRandomR e (CRandT g e m) | |
(ContainsGenError e, Error e, Monad m, CryptoRandomGen g) => MonadCRandom e (CRandT g e m) | |
Error e => MonadTrans (CRandT g e) | |
(Monad m, Error e) => Monad (CRandT g e m) | |
Functor m => Functor (CRandT g e m) | |
(MonadFix m, Error e) => MonadFix (CRandT g e m) | |
(Functor m, Monad m, Error e) => Applicative (CRandT g e m) | |
(MonadIO m, Error e) => MonadIO (CRandT g e m) | |
(MonadCont m, Error e) => MonadCont (CRandT g e m) |
type CRand g e = CRandT g e IdentitySource
Simple users of generators can use CRand for
quick and easy generation of randoms. See
below for a simple use of newGenIO
(from crypto-api),
getCRandom
, getBytes
, and runCRandom
.
getRandPair = do int <- getCRandom bytes <- getBytes 100 return (int, bytes) func = do g <- newGenIO case runCRand getRandPair g of Right ((int,bytes), g') -> useRandomVals (int,bytes) Left x -> handleGenError x
runCRandT :: ContainsGenError e => CRandT g e m a -> g -> m (Either e (a, g))Source
evalCRandT :: (ContainsGenError e, Monad m) => CRandT g e m a -> g -> m (Either e a)Source
newGenCRand :: (CryptoRandomGen g, MonadCRandom GenError m, Functor m) => m gSource
module Crypto.Random