System.Random.NameCase

Expose newtypes of Text to make program tokens

In this module, We represent the very easy operational semantics on the documents with ↓

small = a..z

large = A..Z

num = 0..9

alpha = small | large

alphaNum = alpha | num

symbol = ! | " | # | $ | % | & | | ( | ) | * | + | | | ' | - | . | / | : | ; | = | | ? | @ | [ | | ] | ^ | _ | ` | { | | | } | ~

Documentation

newtype PascalName

Like Konoko, Sugar, and Foo22OGA11RRR at the Random and Arbitrary instance

this = large : {alphaNum}

Constructors

PascalName

Fields

• unPascalName :: Text

Instances

Bounded PascalName

Methods

minBound :: PascalName

maxBound :: PascalName

Show PascalName

Methods

showsPrec :: Int -> PascalName -> ShowS

show :: PascalName -> String

showList :: [PascalName] -> ShowS

IsString PascalName

Methods

fromString :: String -> PascalName

Semigroup PascalName

Methods

(<>) :: PascalName -> PascalName -> PascalName

sconcat :: NonEmpty PascalName -> PascalName

stimes :: Integral b => b -> PascalName -> PascalName

Arbitrary PascalName

Methods

arbitrary :: Gen PascalName

shrink :: PascalName -> [PascalName]

Random PascalName

Methods

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

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

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

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

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

randomIO :: IO PascalName

newtype CamelName

Like "a", "abc" at the Arbitrary Random and instance

this = small : {alphaNum}

Constructors

CamelName

Fields

• unCamelName :: Text

Instances

Bounded CamelName

Methods

minBound :: CamelName

maxBound :: CamelName

Show CamelName

Methods

showsPrec :: Int -> CamelName -> ShowS

show :: CamelName -> String

showList :: [CamelName] -> ShowS

IsString CamelName

Methods

fromString :: String -> CamelName

Semigroup CamelName

Methods

(<>) :: CamelName -> CamelName -> CamelName

sconcat :: NonEmpty CamelName -> CamelName

stimes :: Integral b => b -> CamelName -> CamelName

Arbitrary CamelName

Methods

arbitrary :: Gen CamelName

shrink :: CamelName -> [CamelName]

Random CamelName

Methods

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

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

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

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

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

randomIO :: IO CamelName

newtype SignName

Like "<>", "|", and "<<??!!>!@-~|" at the Random and Arbitrary instance

this = symbol : {symbol}

Constructors

SignName

Fields

• unSignName :: Text

Instances

Bounded SignName

Methods

minBound :: SignName

maxBound :: SignName

Show SignName

Methods

showsPrec :: Int -> SignName -> ShowS

show :: SignName -> String

showList :: [SignName] -> ShowS

IsString SignName

Methods

fromString :: String -> SignName

Semigroup SignName

Methods

(<>) :: SignName -> SignName -> SignName

sconcat :: NonEmpty SignName -> SignName

stimes :: Integral b => b -> SignName -> SignName

Arbitrary SignName

Methods

arbitrary :: Gen SignName

shrink :: SignName -> [SignName]

Random SignName

Methods

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

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

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

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

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

randomIO :: IO SignName

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'