Safe Haskell	None
Language	Haskell2010

System.Random.NameCase

Description

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

Synopsis

Documentation

newtype PascalName Source #

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

this = large : {alphaNum}

Constructors

PascalName
Fields unPascalName :: Text

Instances

Bounded PascalName Source #
Methods minBound :: PascalName # maxBound :: PascalName #
Show PascalName Source #
Methods showsPrec :: Int -> PascalName -> ShowS # show :: PascalName -> String # showList :: [PascalName] -> ShowS #
IsString PascalName Source #
Methods fromString :: String -> PascalName #
Semigroup PascalName Source #
Methods (<>) :: PascalName -> PascalName -> PascalName # sconcat :: NonEmpty PascalName -> PascalName # stimes :: Integral b => b -> PascalName -> PascalName #
Arbitrary PascalName Source #
Methods arbitrary :: Gen PascalName # shrink :: PascalName -> [PascalName] #
Random PascalName Source #
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 Source #

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

this = small : {alphaNum}

Constructors

CamelName
Fields unCamelName :: Text

Instances

Bounded CamelName Source #
Methods minBound :: CamelName # maxBound :: CamelName #
Show CamelName Source #
Methods showsPrec :: Int -> CamelName -> ShowS # show :: CamelName -> String # showList :: [CamelName] -> ShowS #
IsString CamelName Source #
Methods fromString :: String -> CamelName #
Semigroup CamelName Source #
Methods (<>) :: CamelName -> CamelName -> CamelName # sconcat :: NonEmpty CamelName -> CamelName # stimes :: Integral b => b -> CamelName -> CamelName #
Arbitrary CamelName Source #
Methods arbitrary :: Gen CamelName # shrink :: CamelName -> [CamelName] #
Random CamelName Source #
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 Source #

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

this = symbol : {symbol}

Constructors

SignName
Fields unSignName :: Text

Instances

Bounded SignName Source #
Methods minBound :: SignName # maxBound :: SignName #
Show SignName Source #
Methods showsPrec :: Int -> SignName -> ShowS # show :: SignName -> String # showList :: [SignName] -> ShowS #
IsString SignName Source #
Methods fromString :: String -> SignName #
Semigroup SignName Source #
Methods (<>) :: SignName -> SignName -> SignName # sconcat :: NonEmpty SignName -> SignName # stimes :: Integral b => b -> SignName -> SignName #
Arbitrary SignName Source #
Methods arbitrary :: Gen SignName # shrink :: SignName -> [SignName] #
Random SignName Source #
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 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' #