-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Human-friendly textual representations.
--   
--   This package provides an interface for converting between data and its
--   (human-friendly) textual representation.
@package data-textual
@version 0.1


-- | Parsers for numbers written in positional numeral systems.
module Data.Textual.Numerals

-- | Positional numeral system.
class PositionalSystem s
systemName :: PositionalSystem s => s -> String
radixIn :: (PositionalSystem s, Num α) => s -> α
isDigitIn :: PositionalSystem s => s -> Char -> Bool
isNzDigitIn :: PositionalSystem s => s -> Char -> Bool
fromDigitIn :: (PositionalSystem s, Num α) => s -> Char -> Maybe α
fromNzDigitIn :: (PositionalSystem s, Num α) => s -> Char -> Maybe α
unsafeFromDigitIn :: (PositionalSystem s, Num α) => s -> Char -> α
intToDigitIn :: PositionalSystem s => s -> Int -> Char
printDigitIn :: (PositionalSystem s, Printer p) => s -> Char -> p

-- | Positonal numeral system with a power of two radix.
class PositionalSystem s => BitSystem s
digitBitsIn :: BitSystem s => s -> Int
digitMaskIn :: (BitSystem s, Num α) => s -> α
lastDigitIn :: (BitSystem s, Bits α) => s -> α -> Int

-- | The binary numeral system.
data Binary :: *
Binary :: Binary

-- | The octal numeral system.
data Octal :: *
Octal :: Octal

-- | The decimal numeral system.
data Decimal :: *
Decimal :: Decimal

-- | The hexadecimal numeral system.
data Hexadecimal :: *
Hexadecimal :: Hexadecimal

-- | The hexadecimal numeral system, using lower case digits.
data LowHex :: *
LowHex :: LowHex

-- | The hexadecimal numeral system, using upper case digits.
data UpHex :: *
UpHex :: UpHex

-- | Parse a digit of the specified positional numeral system.
digitIn :: (PositionalSystem s, Num α, CharParsing μ) => s -> μ α

-- | Parse a non-zero digit of the specified positional numeral system.
nzDigitIn :: (PositionalSystem s, Num α, CharParsing μ) => s -> μ α

-- | Parse a binary digit.
binDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a non-zero binary digit (<i>'1'</i>).
nzBinDigit :: (Num α, CharParsing μ) => μ α

-- | Parse an octal digit.
octDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a non-zero octal digit.
nzOctDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a decimal digit.
decDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a non-zero decimal digit.
nzDecDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a hexadecimal digit.
hexDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a non-zero hexadecimal digit.
nzHexDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a lower case hexadecimal digit.
lowHexDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a non-zero lower case hexadecimal digit.
nzLowHexDigit :: (Num α, CharParsing μ) => μ α

-- | Parse an upper case hexadecimal digit.
upHexDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a non-zero upper case hexadecimal digit.
nzUpHexDigit :: (Num α, CharParsing μ) => μ α

-- | Parse a non-negative number written in the specified positional
--   numeral system.
nonNegative :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-negative number written in the specified positional
--   numeral system. Leading zeroes are not allowed.
nnCompact :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-negative number written in the specified positional
--   numeral system (up to <i>n</i> digits).
nnUpTo :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a non-negative number written in the specified positional
--   numeral system (up to <i>n</i> digits). Leading zeroes are not
--   allowed.
nncUpTo :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a non-negative number written in the specified positional
--   numeral system, failing on overflow.
nnBounded :: (PositionalSystem s, Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-negative number written in the specified positional
--   numeral system, failing on overflow. Leading zeroes are not allowed.
nncBounded :: (PositionalSystem s, Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-negative binary number written in the specified positional
--   numeral system.
nnBits :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-negative binary number written in the specified positional
--   numeral system. Leading zeroes are not allowed.
nncBits :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-negative binary number written in the specified positional
--   numeral system (up to <i>n</i> digits).
nnBitsUpTo :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a non-negative binary number written in the specified positional
--   numeral system (up to <i>n</i> digits). Leading zeroes are not
--   allowed.
nncBitsUpTo :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a non-negative binary number written in the specified positional
--   numeral system, failing on overflow.
nnbBits :: (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-negative binary number written in the specified positional
--   numeral system, failing on overflow. Leading zeroes are not allowed.
nncbBits :: (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-positive number written in the specified positional
--   numeral system. For example, parsing "123" as a decimal would produce
--   <i>-123</i>, not <i>123</i>.
nonPositive :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-positive number written in the specified positional
--   numeral system. Leading zeroes are not allowed.
npCompact :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-positive number written in the specified positional
--   numeral system (up to <i>n</i> digits).
npUpTo :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a non-positive number written in the specified positional
--   numeral system (up to <i>n</i> digits). Leading zeroes are not
--   allowed.
npcUpTo :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a non-positive number written in the specified positional
--   numeral system, failing on overflow.
npBounded :: (PositionalSystem s, Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-positive number written in the specified positional
--   numeral system, failing on overflow. Leading zeroes are not allowed.
npcBounded :: (PositionalSystem s, Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-positive two's complement binary number written in the
--   specified positional numeral system.
npBits :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-positive two's complement binary number written in the
--   specified positional numeral system. Leading zeroes are not allowed.
npcBits :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-positive two's complement binary number written in the
--   specified positional numeral system (up to <i>n</i> digits).
npBitsUpTo :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a non-positive two's complement binary number written in the
--   specified positional numeral system (up to <i>n</i> digits). Leading
--   zeroes are not allowed.
npcBitsUpTo :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a non-positive two's complement binary number written in the
--   specified positional numeral system, failing on overflow.
npbBits :: (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a non-positive two's complement binary number written in the
--   specified positional numeral system, failing on overflow. Leading
--   zeroes are not allowed.
npcbBits :: (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Sign of a number.
data Sign
NonNegative :: Sign
NonPositive :: Sign

-- | Optional minus sign.
optMinus :: CharParsing μ => μ Sign

-- | Optional minus or plus sign.
optSign :: CharParsing μ => μ Sign

-- | Parse a number written in the specified positional numeral system. The
--   supplied parser is used to determine the sign of the number.
number' :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => μ Sign -> s -> μ α

-- | A shorthand for 'number\'' <a>optMinus</a>.
number :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a number written in the specified positional numeral system. The
--   supplied parser is used to determine the sign of the number. Leading
--   zeroes are not allowed.
compact' :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => μ Sign -> s -> μ α

-- | A shorthand for 'compact\'' <a>optMinus</a>.
compact :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a number written in the specified positional numeral system (up
--   to <i>n</i> digits). The supplied parser is used to determine the sign
--   of the number.
numberUpTo' :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => μ Sign -> s -> Int -> μ α

-- | A shorthand for 'numberUpTo\'' <a>optMinus</a>.
numberUpTo :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a number written in the specified positional numeral system (up
--   to <i>n</i> digits). The supplied parser is used to determine the sign
--   of the number. Leading zeroes are not allowed.
compactUpTo' :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => μ Sign -> s -> Int -> μ α

-- | A shorthand for 'compactUpTo\'' <a>optMinus</a>.
compactUpTo :: (PositionalSystem s, Num α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a number written in the specified positional numeral system,
--   failing on overflow. The supplied parser is used to determine the sign
--   of the number.
bounded' :: (PositionalSystem s, Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) => μ Sign -> s -> μ α

-- | A shorthand for 'bounded\'' <a>optMinus</a>.
bounded :: (PositionalSystem s, Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a number written in the specified positional numeral system,
--   failing on overflow. The supplied parser is used to determine the sign
--   of the number. Leading zeroes are not allowed.
cBounded' :: (PositionalSystem s, Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) => μ Sign -> s -> μ α

-- | A shorthand for 'cBounded\'' <a>optMinus</a>.
cBounded :: (PositionalSystem s, Ord α, Bounded α, Integral α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a (two's complement) binary number written in the specified
--   positional numeral system. The supplied parser is used to determine
--   the sign of the number.
bits' :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => μ Sign -> s -> μ α

-- | A shorthand for 'bits\'' <a>optMinus</a>.
bits :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a (two's complement) binary number written in the specified
--   positional numeral system. The supplied parser is used to determine
--   the sign of the number. Leading zeroes are not allowed.
cBits' :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => μ Sign -> s -> μ α

-- | A shorthand for 'cBits\'' <a>optMinus</a>.
cBits :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a (two's complement) binary number written in the specified
--   positional numeral system (up to <i>n</i> digits). The supplied parser
--   is used to determine the sign of the number.
bitsUpTo' :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => μ Sign -> s -> Int -> μ α

-- | A shorthand for 'bitsUpTo\'' <a>optMinus</a>.
bitsUpTo :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a (two's complement) binary number written in the specified
--   positional numeral system (up to <i>n</i> digits). The supplied parser
--   is used to determine the sign of the number. Leading zeroes are not
--   allowed.
cBitsUpTo' :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => μ Sign -> s -> Int -> μ α

-- | A shorthand for 'cBitsUpTo\'' <a>optMinus</a>.
cBitsUpTo :: (BitSystem s, Num α, Bits α, Monad μ, CharParsing μ) => s -> Int -> μ α

-- | Parse a (two's complement) binary number written in the specified
--   positional numeral system, failing on overflow. The supplied parser is
--   used to determine the sign of the number.
bBits' :: (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => μ Sign -> s -> μ α

-- | A shorthand for 'bBits\'' <a>optMinus</a>.
bBits :: (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

-- | Parse a (two's complement) binary number written in the specified
--   positional numeral system, failing on overflow. The supplied parser is
--   used to determine the sign of the number. Leading zeroes are not
--   allowed.
cbBits' :: (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => μ Sign -> s -> μ α

-- | A shorthand for 'cbBits\'' <a>optMinus</a>.
cbBits :: (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α
instance Typeable Sign
instance Eq Sign
instance Show Sign
instance Read Sign


-- | Working with human-friendly (as opposed to the compiler-friendly
--   <a>Show</a> and <a>Read</a>) textual representations.
module Data.Textual

-- | The default printer for values of a type.
class Printable α
print :: (Printable α, Printer p) => α -> p

-- | A shorthand for <tt><a>maybe</a> <a>mempty</a> <a>print</a></tt>.
maybePrint :: (Printer p, Printable α) => Maybe α -> p

-- | A shorthand for <tt><a>buildString</a> . <a>print</a></tt>.
toString :: Printable α => α -> String

-- | A shorthand for <tt><a>buildText</a> . <a>print</a></tt>.
toText :: Printable α => α -> Text

-- | A shorthand for <tt><a>buildLazyText</a> . <a>print</a></tt>.
toLazyText :: Printable α => α -> Text

-- | A shorthand for <tt><a>buildAscii</a> . <a>print</a></tt>.
toAscii :: Printable α => α -> ByteString

-- | A shorthand for <tt><a>buildLazyAscii</a> . <a>print</a></tt>.
toLazyAscii :: Printable α => α -> ByteString

-- | A shorthand for <tt><a>buildUtf8</a> . <a>print</a></tt>.
toUtf8 :: Printable α => α -> ByteString

-- | A shorthand for <tt><a>buildLazyUtf8</a> . <a>print</a></tt>.
toLazyUtf8 :: Printable α => α -> ByteString

-- | The default parser for values of a type, must satisfy <tt>
--   <a>fromString</a> (<a>toString</a> <i>x</i>) = <a>Just</a> <i>x</i>
--   </tt>
class Printable α => Textual α
textual :: (Textual α, Monad μ, CharParsing μ) => μ α

-- | Hint the type system about the type of the first argument.
hintType :: α -> Proxy α -> α

-- | Hint the type system about the type constructor.
hintType1 :: f α -> Proxy f -> f α

-- | Hint the type system about the type argument.
hintTypeArg :: f α -> Proxy α -> f α

-- | <i>()</i> proxy value.
aUnit :: Proxy ()

-- | <a>Char</a> proxy value.
aChar :: Proxy Char

-- | <a>Integer</a> proxy value.
anInteger :: Proxy Integer

-- | <a>Int</a> proxy value.
anInt :: Proxy Int

-- | <a>Int8</a> proxy value.
anInt8 :: Proxy Int8

-- | <a>Int16</a> proxy value.
anInt16 :: Proxy Int16

-- | <a>Int32</a> proxy value.
anInt32 :: Proxy Int32

-- | <a>Int64</a> proxy value.
anInt64 :: Proxy Int64

-- | <a>Word</a> proxy value.
aWord :: Proxy Word

-- | <a>Word8</a> proxy value.
aWord8 :: Proxy Word8

-- | <a>Word16</a> proxy value.
aWord16 :: Proxy Word16

-- | <a>Word32</a> proxy value.
aWord32 :: Proxy Word32

-- | <a>Word64</a> proxy value.
aWord64 :: Proxy Word64

-- | <a>Float</a> proxy value.
aFloat :: Proxy Float

-- | <a>Double</a> proxy value.
aDouble :: Proxy Double

-- | <a>Maybe</a> proxy value.
aMaybe :: Proxy Maybe

-- | <a>Maybe</a> <i>α</i> proxy value.
aMaybeOf :: Proxy α -> Proxy (Maybe α)

-- | List proxy value.
aList :: Proxy []

-- | List of <i>α</i> proxy value.
aListOf :: Proxy α -> Proxy ([α])

-- | Parsing result.
data Parsed α
Parsed :: α -> Parsed α
Malformed :: [String] -> String -> Parsed α

-- | Map <a>Parsed</a> to <a>True</a> and <a>Malformed</a> to <a>False</a>.
isParsed :: Parsed α -> Bool

-- | Map <a>Parsed</a> to <a>False</a> and <a>Malformed</a> to <a>True</a>.
isMalformed :: Parsed α -> Bool

-- | Map <a>Parsed</a> values to <a>Just</a> and <a>Malformed</a> to
--   <a>Nothing</a>.
maybeParsed :: Parsed α -> Maybe α

-- | Use the built-in parser to parse a string. Intended for testing only.
builtInParser :: (forall μ. (Monad μ, CharParsing μ) => μ α) -> String -> Parsed α

-- | Parse a <a>String</a> to extract the <a>Textual</a> value.
parseString :: Textual α => String -> Parsed α

-- | Provide a hint for the type system when using <a>parseString</a>.
parseStringAs :: Textual α => Proxy α -> String -> Parsed α

-- | Parse a <a>Text</a> to extract the <a>Textual</a> value.
parseText :: Textual α => Text -> Parsed α

-- | Provide a hint for the type system when using <a>parseText</a>.
parseTextAs :: Textual α => Proxy α -> Text -> Parsed α

-- | Parse a lazy <a>Text</a> to extract the <a>Textual</a> value.
parseLazyText :: Textual α => Text -> Parsed α

-- | Provide a hint for the type system when using <a>parseLazyText</a>.
parseLazyTextAs :: Textual α => Proxy α -> Text -> Parsed α

-- | Decode and parse an ASCII <a>ByteString</a> to extract the
--   <a>Textual</a> value.
parseAscii :: Textual α => ByteString -> Parsed α

-- | Provide a hint for the type system when using <a>parseAscii</a>.
parseAsciiAs :: Textual α => Proxy α -> ByteString -> Parsed α

-- | Decode and parse a lazy ASCII <a>ByteString</a> to extract the
--   <a>Textual</a> value.
parseLazyAscii :: Textual α => ByteString -> Parsed α

-- | Provide a hint for the type system when using <a>parseLazyAscii</a>.
parseLazyAsciiAs :: Textual α => ByteString -> Parsed α

-- | Decode and parse a UTF-8 <a>ByteString</a> to extract the
--   <a>Textual</a> value.
parseUtf8 :: Textual α => ByteString -> Parsed α

-- | Provide a hint for the type system when using <a>parseUtf8</a>.
parseUtf8As :: Textual α => Proxy α -> ByteString -> Parsed α

-- | Decode and parse a lazy UTF-8 <a>ByteString</a> to extract the
--   <a>Textual</a> value.
parseLazyUtf8 :: Textual α => ByteString -> Parsed α

-- | Provide a hint for the type system when using <a>parseLazyUtf8</a>.
parseLazyUtf8As :: Textual α => Proxy α -> ByteString -> Parsed α

-- | A shorthand for <tt><a>maybeParsed</a> . <a>parseString</a></tt>
fromString :: Textual α => String -> Maybe α

-- | Provide a hint for the type system when using <a>fromString</a>.
fromStringAs :: Textual α => Proxy α -> String -> Maybe α

-- | A shorthand for <tt><a>maybeParsed</a> . <a>parseText</a></tt>
fromText :: Textual α => Text -> Maybe α

-- | Provide a hint for the type system when using <a>fromText</a>.
fromTextAs :: Textual α => Proxy α -> Text -> Maybe α

-- | A shorthand for <tt><a>maybeParsed</a> . <a>parseLazyText</a></tt>
fromLazyText :: Textual α => Text -> Maybe α

-- | Provide a hint for the type system when using <a>fromLazyText</a>.
fromLazyTextAs :: Textual α => Proxy α -> Text -> Maybe α

-- | A shorthand for <tt><a>maybeParsed</a> . <a>parseAscii</a></tt>
fromAscii :: Textual α => ByteString -> Maybe α

-- | Provide a hint for the type system when using <a>fromAscii</a>.
fromAsciiAs :: Textual α => Proxy α -> ByteString -> Maybe α

-- | A shorthand for <tt><a>maybeParsed</a> . <a>parseLazyAscii</a></tt>
fromLazyAscii :: Textual α => ByteString -> Maybe α

-- | Provide a hint for the type system when using <a>fromLazyAscii</a>.
fromLazyAsciiAs :: Textual α => Proxy α -> ByteString -> Maybe α

-- | A shorthand for <tt><a>maybeParsed</a> . <a>parseUtf8</a></tt>
fromUtf8 :: Textual α => ByteString -> Maybe α

-- | Provide a hint for the type system when using <a>fromUtf8</a>.
fromUtf8As :: Textual α => Proxy α -> ByteString -> Maybe α

-- | A shorthand for <tt><a>maybeParsed</a> . <a>parseLazyUtf8</a></tt>
fromLazyUtf8 :: Textual α => ByteString -> Maybe α

-- | Provide a hint for the type system when using <a>fromLazyUtf8</a>.
fromLazyUtf8As :: Textual α => Proxy α -> ByteString -> Maybe α
instance Typeable1 Parsed
instance Functor Parsed
instance Foldable Parsed
instance Traversable Parsed
instance Eq α => Eq (Parsed α)
instance Show α => Show (Parsed α)
instance Monad Parser
instance CharParsing Parser
instance Parsing Parser
instance Alternative Parser
instance Applicative Parser
instance Functor Parser
instance Alternative Parsed
instance Applicative Parsed
instance Textual Word64
instance Textual Word32
instance Textual Word16
instance Textual Word8
instance Textual Word
instance Textual Int64
instance Textual Int32
instance Textual Int16
instance Textual Int8
instance Textual Int
instance Textual Integer
instance Textual Char
instance Printable Double
instance Printable Float
instance Printable Word64
instance Printable Word32
instance Printable Word16
instance Printable Word8
instance Printable Word
instance Printable Int64
instance Printable Int32
instance Printable Int16
instance Printable Int8
instance Printable Int
instance Printable Integer
instance Printable Text
instance Printable Text
instance Printable String
instance Printable Char