Data.Parameterized.Nonce

This module provides a simple generator of new indexes in the ST monad. It is predictable and not intended for cryptographic purposes.

This module also provides a global nonce generator that will generate 2^64 nonces before repeating.

NOTE: The TestEquality and OrdF instances for the Nonce type simply compare the generated nonce values and then assert to the compiler (via unsafeCoerce) that the types ascribed to the nonces are equal if their values are equal.

NonceGenerator

data NonceGenerator (m :: Type -> Type) (s :: Type)

Provides a monadic action for getting fresh typed names.

The first type parameter m is the monad used for generating names, and the second parameter s is used for the counter.

freshNonce :: forall m s k (tp :: k). NonceGenerator m s -> m (Nonce s tp)

countNoncesGenerated :: NonceGenerator m s -> m Integer

The number of nonces generated so far by this generator. Only really useful for profiling.

data Nonce (s :: Type) (tp :: k)

An index generated by the counter.

Instances

TestEquality (Nonce s :: k -> Type)

Defined in Data.Parameterized.Nonce

Methods

testEquality :: forall (a :: k0) (b :: k0). Nonce s a -> Nonce s b -> Maybe (a :~: b)

HashableF (Nonce s :: k -> Type)

Defined in Data.Parameterized.Nonce

Methods

hashWithSaltF :: forall (tp :: k0). Int -> Nonce s tp -> Int

hashF :: forall (tp :: k0). Nonce s tp -> Int

ShowF (Nonce s :: k -> Type)

Defined in Data.Parameterized.Nonce

Methods

withShow :: forall p q (tp :: k0) a. p (Nonce s) -> q tp -> (Show (Nonce s tp) => a) -> a

showF :: forall (tp :: k0). Nonce s tp -> String

showsPrecF :: forall (tp :: k0). Int -> Nonce s tp -> String -> String

OrdF (Nonce s :: k -> Type)

Defined in Data.Parameterized.Nonce

Methods

compareF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> OrderingF x y

leqF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> Bool

ltF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> Bool

geqF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> Bool

gtF :: forall (x :: k0) (y :: k0). Nonce s x -> Nonce s y -> Bool

Eq (Nonce s tp)

Defined in Data.Parameterized.Nonce

Methods

(==) :: Nonce s tp -> Nonce s tp -> Bool

(/=) :: Nonce s tp -> Nonce s tp -> Bool

Ord (Nonce s tp)

Defined in Data.Parameterized.Nonce

Methods

compare :: Nonce s tp -> Nonce s tp -> Ordering

(<) :: Nonce s tp -> Nonce s tp -> Bool

(<=) :: Nonce s tp -> Nonce s tp -> Bool

(>) :: Nonce s tp -> Nonce s tp -> Bool

(>=) :: Nonce s tp -> Nonce s tp -> Bool

max :: Nonce s tp -> Nonce s tp -> Nonce s tp

min :: Nonce s tp -> Nonce s tp -> Nonce s tp

Show (Nonce s tp)

Defined in Data.Parameterized.Nonce

Methods

showsPrec :: Int -> Nonce s tp -> ShowS

show :: Nonce s tp -> String

showList :: [Nonce s tp] -> ShowS

Hashable (Nonce s tp)

Defined in Data.Parameterized.Nonce

Methods

hashWithSalt :: Int -> Nonce s tp -> Int

hash :: Nonce s tp -> Int

indexValue :: Nonce s tp -> Word64

Accessing a nonce generator

newSTNonceGenerator :: ST t (Some (NonceGenerator (ST t)))

Create a new nonce generator in the ST monad.

newIONonceGenerator :: IO (Some (NonceGenerator IO))

Create a new nonce generator in the IO monad.

withIONonceGenerator :: (forall s. NonceGenerator IO s -> IO r) -> IO r

Run an IO computation with a new nonce generator in the IO monad.

withSTNonceGenerator :: (forall s. NonceGenerator (ST t) s -> ST t r) -> ST t r

Run an ST computation with a new nonce generator in the ST monad.

runSTNonceGenerator :: (forall s. NonceGenerator (ST s) s -> ST s a) -> a

This combines runST and newSTNonceGenerator to create a nonce generator that shares the same phantom type parameter as the ST monad.

This can be used to reduce the number of type parameters when we know a ST computation only needs a single NonceGenerator.

Global nonce generator

withGlobalSTNonceGenerator :: (forall t. NonceGenerator (ST t) t -> ST t r) -> r

Create a new counter.

data GlobalNonceGenerator

globalNonceGenerator :: NonceGenerator IO GlobalNonceGenerator

A nonce generator that uses a globally-defined counter.