Safe Haskell	None
Language	Haskell2010

System.Random.NameCase.Combinators

Description

Please see NameCase

Synopsis

Documentation

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

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 Source #

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

newtype VisibleChar Source #

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 Source #
Methods minBound :: VisibleChar # maxBound :: VisibleChar #
Show VisibleChar Source #
Methods showsPrec :: Int -> VisibleChar -> ShowS # show :: VisibleChar -> String # showList :: [VisibleChar] -> ShowS #
Arbitrary VisibleChar Source #
Methods arbitrary :: Gen VisibleChar # shrink :: VisibleChar -> [VisibleChar] #
Random VisibleChar Source #
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] Source #

All of VisibleChar (the table)

newtype UpperChar Source #

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

Constructors

UpperChar
Fields unUpperChar :: Char

Instances

Bounded UpperChar Source #
Methods minBound :: UpperChar # maxBound :: UpperChar #
Show UpperChar Source #
Methods showsPrec :: Int -> UpperChar -> ShowS # show :: UpperChar -> String # showList :: [UpperChar] -> ShowS #
Arbitrary UpperChar Source #
Methods arbitrary :: Gen UpperChar # shrink :: UpperChar -> [UpperChar] #
Random UpperChar Source #
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] Source #

A subset of visibleChars

newtype LowerChar Source #

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

Constructors

LowerChar
Fields unLowerChar :: Char

Instances

Bounded LowerChar Source #
Methods minBound :: LowerChar # maxBound :: LowerChar #
Show LowerChar Source #
Methods showsPrec :: Int -> LowerChar -> ShowS # show :: LowerChar -> String # showList :: [LowerChar] -> ShowS #
Arbitrary LowerChar Source #
Methods arbitrary :: Gen LowerChar # shrink :: LowerChar -> [LowerChar] #
Random LowerChar Source #
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] Source #

A subset of visibleChars

newtype AlphaNumChar Source #

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

Constructors

AlphaNumChar
Fields unAlphaNumChar :: Char

Instances

Bounded AlphaNumChar Source #
Methods minBound :: AlphaNumChar # maxBound :: AlphaNumChar #
Show AlphaNumChar Source #
Methods showsPrec :: Int -> AlphaNumChar -> ShowS # show :: AlphaNumChar -> String # showList :: [AlphaNumChar] -> ShowS #
Arbitrary AlphaNumChar Source #
Methods arbitrary :: Gen AlphaNumChar # shrink :: AlphaNumChar -> [AlphaNumChar] #
Random AlphaNumChar Source #
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] Source #

A subset of visibleChars

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

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

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

unAlphaNums :: List' AlphaNumChar -> [Char] Source #

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

newtype SymbolChar Source #

symbolic characters at the Random and Arbitrary instance

Constructors

SymbolChar
Fields unSymbolChar :: Char

Instances

Bounded SymbolChar Source #
Methods minBound :: SymbolChar # maxBound :: SymbolChar #
Show SymbolChar Source #
Methods showsPrec :: Int -> SymbolChar -> ShowS # show :: SymbolChar -> String # showList :: [SymbolChar] -> ShowS #
Arbitrary SymbolChar Source #
Methods arbitrary :: Gen SymbolChar # shrink :: SymbolChar -> [SymbolChar] #
Random SymbolChar Source #
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] Source #

A subset of visibleChars

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

Similar to AlphaNums

unSymbols :: List' SymbolChar -> [Char] Source #

newtype List' a Source #

A workaround for the Random orphan instance

Constructors

List'
Fields unList' :: [a]

Instances

Functor List' Source #
Methods fmap :: (a -> b) -> List' a -> List' b # (<$) :: a -> List' b -> List' a #
Bounded a => Bounded (List' a) Source #
Methods minBound :: List' a # maxBound :: List' a #
(Bounded a, Random a) => Random (List' a) Source #
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' Source #

A workaround for the Random orphan instance

Constructors

Text'
Fields unText' :: Text

Instances

Bounded Text' Source #
Methods minBound :: Text' # maxBound :: Text' #
Random Text' Source #
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' #