System.Random.NameCase.Combinators

Please see NameCase

Documentation

elementsR :: RandomGen g => [a] -> (a -> Int) -> (a, a) -> g -> (a, g)

Like elements and System.Random.randomR'. Get a element from `[a]`, using a value of `Random Int`, the `(a, a)`, and the `a -> Int`.

`elementsR visibleChars ord (x, y)`

errorOnUnexpected :: String -> String -> a

Break the program. Notify that an error on unexpected conditions.

newtype VisibleChar

Similar to 'VisibleChar, but only visible and ascii characters are allowed in the Random and the Arbitrary instances

Constructors

VisibleChar

Fields

• unVisibleChar :: Char

Instances

Bounded VisibleChar

Methods

minBound :: VisibleChar

maxBound :: VisibleChar

Show VisibleChar

Methods

showsPrec :: Int -> VisibleChar -> ShowS

show :: VisibleChar -> String

showList :: [VisibleChar] -> ShowS

Arbitrary VisibleChar

Methods

arbitrary :: Gen VisibleChar

shrink :: VisibleChar -> [VisibleChar]

Random VisibleChar

Methods

randomR :: RandomGen g => (VisibleChar, VisibleChar) -> g -> (VisibleChar, g)

random :: RandomGen g => g -> (VisibleChar, g)

randomRs :: RandomGen g => (VisibleChar, VisibleChar) -> g -> [VisibleChar]

randoms :: RandomGen g => g -> [VisibleChar]

randomRIO :: (VisibleChar, VisibleChar) -> IO VisibleChar

randomIO :: IO VisibleChar

visibleChars :: [VisibleChar]

All of VisibleChar (the table)

newtype UpperChar

A..Z at the Random and Arbitrary instance (a subset of VisibleChar)

Constructors

UpperChar

Fields

• unUpperChar :: Char

Instances

Bounded UpperChar

Methods

minBound :: UpperChar

maxBound :: UpperChar

Show UpperChar

Methods

showsPrec :: Int -> UpperChar -> ShowS

show :: UpperChar -> String

showList :: [UpperChar] -> ShowS

Arbitrary UpperChar

Methods

arbitrary :: Gen UpperChar

shrink :: UpperChar -> [UpperChar]

Random UpperChar

Methods

randomR :: RandomGen g => (UpperChar, UpperChar) -> g -> (UpperChar, g)

random :: RandomGen g => g -> (UpperChar, g)

randomRs :: RandomGen g => (UpperChar, UpperChar) -> g -> [UpperChar]

randoms :: RandomGen g => g -> [UpperChar]

randomRIO :: (UpperChar, UpperChar) -> IO UpperChar

randomIO :: IO UpperChar

upperChars :: [UpperChar]

A subset of visibleChars

newtype LowerChar

'a'..'z' at the Random and Arbitrary instance

Constructors

LowerChar

Fields

• unLowerChar :: Char

Instances

Bounded LowerChar

Methods

minBound :: LowerChar

maxBound :: LowerChar

Show LowerChar

Methods

showsPrec :: Int -> LowerChar -> ShowS

show :: LowerChar -> String

showList :: [LowerChar] -> ShowS

Arbitrary LowerChar

Methods

arbitrary :: Gen LowerChar

shrink :: LowerChar -> [LowerChar]

Random LowerChar

Methods

randomR :: RandomGen g => (LowerChar, LowerChar) -> g -> (LowerChar, g)

random :: RandomGen g => g -> (LowerChar, g)

randomRs :: RandomGen g => (LowerChar, LowerChar) -> g -> [LowerChar]

randoms :: RandomGen g => g -> [LowerChar]

randomRIO :: (LowerChar, LowerChar) -> IO LowerChar

randomIO :: IO LowerChar

lowerChars :: [LowerChar]

A subset of visibleChars

newtype AlphaNumChar

A..Z, a..z, or 0..9 at the Random and Arbitrary instance

Constructors

AlphaNumChar

Fields

• unAlphaNumChar :: Char

Instances

Bounded AlphaNumChar

Methods

minBound :: AlphaNumChar

maxBound :: AlphaNumChar

Show AlphaNumChar

Methods

showsPrec :: Int -> AlphaNumChar -> ShowS

show :: AlphaNumChar -> String

showList :: [AlphaNumChar] -> ShowS

Arbitrary AlphaNumChar

Methods

arbitrary :: Gen AlphaNumChar

shrink :: AlphaNumChar -> [AlphaNumChar]

Random AlphaNumChar

Methods

randomR :: RandomGen g => (AlphaNumChar, AlphaNumChar) -> g -> (AlphaNumChar, g)

random :: RandomGen g => g -> (AlphaNumChar, g)

randomRs :: RandomGen g => (AlphaNumChar, AlphaNumChar) -> g -> [AlphaNumChar]

randoms :: RandomGen g => g -> [AlphaNumChar]

randomRIO :: (AlphaNumChar, AlphaNumChar) -> IO AlphaNumChar

randomIO :: IO AlphaNumChar

alphaNumChars :: [AlphaNumChar]

A subset of visibleChars

pattern AlphaNums :: [Char] -> List' AlphaNumChar

>>> xs = AlphaNums ['A', 'b', '3']
>>> :t xs
List' AlphaNumChar

>>> AlphaNums xs' = xs
>>> :t xs'
[Char]

unAlphaNums :: List' AlphaNumChar -> [Char]

The dual of AlphaNums, This is imposed the same restriction of AlphaNums to the return type

newtype SymbolChar

symbolic characters at the Random and Arbitrary instance

Constructors

SymbolChar

Fields

• unSymbolChar :: Char

Instances

Bounded SymbolChar

Methods

minBound :: SymbolChar

maxBound :: SymbolChar

Show SymbolChar

Methods

showsPrec :: Int -> SymbolChar -> ShowS

show :: SymbolChar -> String

showList :: [SymbolChar] -> ShowS

Arbitrary SymbolChar

Methods

arbitrary :: Gen SymbolChar

shrink :: SymbolChar -> [SymbolChar]

Random SymbolChar

Methods

randomR :: RandomGen g => (SymbolChar, SymbolChar) -> g -> (SymbolChar, g)

random :: RandomGen g => g -> (SymbolChar, g)

randomRs :: RandomGen g => (SymbolChar, SymbolChar) -> g -> [SymbolChar]

randoms :: RandomGen g => g -> [SymbolChar]

randomRIO :: (SymbolChar, SymbolChar) -> IO SymbolChar

randomIO :: IO SymbolChar

symbolChars :: [SymbolChar]

A subset of visibleChars

pattern Symbols :: [Char] -> List' SymbolChar

Similar to AlphaNums

unSymbols :: List' SymbolChar -> [Char]

newtype List' a

A workaround for the Random orphan instance

Constructors

List'

Fields

• unList' :: [a]

Instances

Functor List'

Methods

fmap :: (a -> b) -> List' a -> List' b

(<$) :: a -> List' b -> List' a

Bounded a => Bounded (List' a)

Methods

minBound :: List' a

maxBound :: List' a

(Bounded a, Random a) => Random (List' a)

Methods

randomR :: RandomGen g => (List' a, List' a) -> g -> (List' a, g)

random :: RandomGen g => g -> (List' a, g)

randomRs :: RandomGen g => (List' a, List' a) -> g -> [List' a]

randoms :: RandomGen g => g -> [List' a]

randomRIO :: (List' a, List' a) -> IO (List' a)

randomIO :: IO (List' a)

newtype Text'

A workaround for the Random orphan instance

Constructors

Text'

Fields

• unText' :: Text

Instances

Bounded Text'

Methods

minBound :: Text'

maxBound :: Text'

Random Text'

Methods

randomR :: RandomGen g => (Text', Text') -> g -> (Text', g)

random :: RandomGen g => g -> (Text', g)

randomRs :: RandomGen g => (Text', Text') -> g -> [Text']

randoms :: RandomGen g => g -> [Text']

randomRIO :: (Text', Text') -> IO Text'

randomIO :: IO Text'