-- 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.3.0.3


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

-- | Positional numeral system.
class PositionalSystem s

-- | The name of the system (e.g. "binary", "decimal").
systemName :: PositionalSystem s => s -> String

-- | The radix of the system.
radixIn :: (PositionalSystem s, Num α) => s -> α

-- | Test if a character is a digit.
isDigitIn :: PositionalSystem s => s -> Char -> Bool

-- | Test if a character is a non-zero digit.
isNzDigitIn :: PositionalSystem s => s -> Char -> Bool

-- | Map digits to the corresponding numbers. Return <a>Nothing</a> on
--   other inputs.
fromDigitIn :: (PositionalSystem s, Num α) => s -> Char -> Maybe α

-- | Map non-zero digits to the corresponding numbers. Return
--   <a>Nothing</a> on other inputs.
fromNzDigitIn :: (PositionalSystem s, Num α) => s -> Char -> Maybe α

-- | Map digits to the corresponding numbers. No checks are performed.
unsafeFromDigitIn :: (PositionalSystem s, Num α) => s -> Char -> α

-- | Map <a>Int</a> values to the corresponding digits. Inputs <i>must</i>
--   be non-negative and less than the radix.
intToDigitIn :: PositionalSystem s => s -> Int -> Char

-- | Print a digit.
printDigitIn :: (PositionalSystem s, Printer p) => s -> Char -> p
printZeroIn :: (PositionalSystem s, Printer p) => s -> p

-- | Positonal numeral system with a power of two radix.
class PositionalSystem s => BitSystem s

-- | Numer of bits occupied by a digit.
digitBitsIn :: BitSystem s => s -> Int

-- | The number that has <a>digitBitsIn</a> least significant bits set to
--   ones and all the other bits set to zeroes.
digitMaskIn :: (BitSystem s, Num α) => s -> α

-- | Map the last digit of a number to the corresponding <a>Int</a> value.
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 :: forall s μ α. (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 :: forall s μ α. (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α

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

-- | Negate the supplied value if the sign is <a>NonPositive</a> and return
--   it as it is otherwise.
applySign :: Num α => 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 <a>number'</a> <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 <a>compact'</a> <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 <a>numberUpTo'</a> <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 <a>compactUpTo'</a> <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 <a>bounded'</a> <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 <a>cBounded'</a> <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 <a>bits'</a> <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 <a>cBits'</a> <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 <a>bitsUpTo'</a> <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 <a>cBitsUpTo'</a> <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 <a>bBits'</a> <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 <a>cbBits'</a> <a>optMinus</a>.
cbBits :: (BitSystem s, Ord α, Bounded α, Num α, Bits α, Monad μ, CharParsing μ) => s -> μ α
instance GHC.Read.Read Data.Textual.Integral.Sign
instance GHC.Show.Show Data.Textual.Integral.Sign
instance GHC.Classes.Eq Data.Textual.Integral.Sign


-- | Parsers for fractions.
module Data.Textual.Fractional

-- | Positional numeral system.
class PositionalSystem s

-- | The name of the system (e.g. "binary", "decimal").
systemName :: PositionalSystem s => s -> String

-- | The radix of the system.
radixIn :: (PositionalSystem s, Num α) => s -> α

-- | Test if a character is a digit.
isDigitIn :: PositionalSystem s => s -> Char -> Bool

-- | Test if a character is a non-zero digit.
isNzDigitIn :: PositionalSystem s => s -> Char -> Bool

-- | Map digits to the corresponding numbers. Return <a>Nothing</a> on
--   other inputs.
fromDigitIn :: (PositionalSystem s, Num α) => s -> Char -> Maybe α

-- | Map non-zero digits to the corresponding numbers. Return
--   <a>Nothing</a> on other inputs.
fromNzDigitIn :: (PositionalSystem s, Num α) => s -> Char -> Maybe α

-- | Map digits to the corresponding numbers. No checks are performed.
unsafeFromDigitIn :: (PositionalSystem s, Num α) => s -> Char -> α

-- | Map <a>Int</a> values to the corresponding digits. Inputs <i>must</i>
--   be non-negative and less than the radix.
intToDigitIn :: PositionalSystem s => s -> Int -> Char

-- | Print a digit.
printDigitIn :: (PositionalSystem s, Printer p) => s -> Char -> p
printZeroIn :: (PositionalSystem s, Printer p) => s -> p

-- | 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 upper case digits.
data UpHex
UpHex :: UpHex

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

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

-- | Negate the supplied value if the sign is <a>NonPositive</a> and return
--   it as it is otherwise.
applySign :: Num α => Sign -> α -> α

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

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

-- | Optionality characteristic.
data Optional
Optional :: Optional
Required :: Optional

-- | True if the supplied value is <a>Optional</a> and false otherwise.
isOptional :: Optional -> Bool

-- | True if the supplied value is <a>Required</a> and false otherwise.
isRequired :: Optional -> Bool

-- | Accept a slash and return <a>Required</a>. Otherwise return
--   <a>Optional</a>.
optSlash :: (Monad μ, CharParsing μ) => μ Optional

-- | Parse a fraction. The numerator and the denominator are expected to be
--   written in the specified positional numeral system.
fraction' :: (PositionalSystem s, Fractional α, Monad μ, CharParsing μ) => μ Sign -> s -> μ Optional -> μ α

-- | A shorthand for <a>fraction'</a> <a>optMinus</a> <a>Decimal</a>
--   <a>optSlash</a>.
fraction :: (Fractional α, Monad μ, CharParsing μ) => μ α

-- | Start of a decimal exponent. Accepts <i><tt>e</tt></i> or
--   <i><tt>E</tt></i> followed by an optional sign. Otherwise
--   <a>Nothing</a> is returned.
decExpSign :: (Monad μ, CharParsing μ) => μ (Maybe Sign)

-- | Start of a hexadecimal exponent. Accepts <i><tt>p</tt></i> or
--   <i><tt>P</tt></i> followed by an optional sign. Otherwise
--   <a>Nothing</a> is returned.
hexExpSign :: (Monad μ, CharParsing μ) => μ (Maybe Sign)

-- | <i>s</i>-fraction parser.
fractional' :: (PositionalSystem s, Fractional α, Monad μ, CharParsing μ) => μ Sign -> s -> Optional -> μ () -> μ (Maybe Sign) -> μ α

-- | Decimal fraction parser.
fractional :: (Monad μ, Fractional α, CharParsing μ) => μ α


-- | 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 μ) => μ α

-- | 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> 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 α => p α -> ByteString -> Maybe α
instance GHC.Show.Show α => GHC.Show.Show (Data.Textual.Parsed α)
instance GHC.Classes.Eq α => GHC.Classes.Eq (Data.Textual.Parsed α)
instance Data.Traversable.Traversable Data.Textual.Parsed
instance Data.Foldable.Foldable Data.Textual.Parsed
instance GHC.Base.Functor Data.Textual.Parsed
instance GHC.Base.Functor Data.Textual.Parser
instance GHC.Base.Applicative Data.Textual.Parser
instance GHC.Base.Alternative Data.Textual.Parser
instance Text.Parser.Combinators.Parsing Data.Textual.Parser
instance Text.Parser.Char.CharParsing Data.Textual.Parser
instance GHC.Base.Monad Data.Textual.Parser
instance GHC.Base.Applicative Data.Textual.Parsed
instance GHC.Base.Alternative Data.Textual.Parsed
instance Data.Textual.Textual GHC.Types.Char
instance Data.Textual.Textual GHC.Integer.Type.Integer
instance Data.Textual.Textual GHC.Types.Int
instance Data.Textual.Textual GHC.Int.Int8
instance Data.Textual.Textual GHC.Int.Int16
instance Data.Textual.Textual GHC.Int.Int32
instance Data.Textual.Textual GHC.Int.Int64
instance Data.Textual.Textual GHC.Types.Word
instance Data.Textual.Textual GHC.Word.Word8
instance Data.Textual.Textual GHC.Word.Word16
instance Data.Textual.Textual GHC.Word.Word32
instance Data.Textual.Textual GHC.Word.Word64
instance GHC.Real.Integral α => Data.Textual.Textual (GHC.Real.Ratio α)
instance Data.Fixed.HasResolution α => Data.Textual.Textual (Data.Fixed.Fixed α)
instance Data.Textual.Printable GHC.Types.Char
instance Data.Textual.Printable GHC.Base.String
instance Data.Textual.Printable Data.Text.Internal.Text
instance Data.Textual.Printable Data.Text.Internal.Lazy.Text
instance Data.Textual.Printable GHC.Integer.Type.Integer
instance Data.Textual.Printable GHC.Types.Int
instance Data.Textual.Printable GHC.Int.Int8
instance Data.Textual.Printable GHC.Int.Int16
instance Data.Textual.Printable GHC.Int.Int32
instance Data.Textual.Printable GHC.Int.Int64
instance Data.Textual.Printable GHC.Types.Word
instance Data.Textual.Printable GHC.Word.Word8
instance Data.Textual.Printable GHC.Word.Word16
instance Data.Textual.Printable GHC.Word.Word32
instance Data.Textual.Printable GHC.Word.Word64
instance GHC.Real.Integral α => Data.Textual.Printable (GHC.Real.Ratio α)
instance Data.Fixed.HasResolution α => Data.Textual.Printable (Data.Fixed.Fixed α)
instance Data.Textual.Printable GHC.Types.Float
instance Data.Textual.Printable GHC.Types.Double