-- 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
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
printZeroIn :: (PositionalSystem s, Printer p) => s -> p
class PositionalSystem s => BitSystem s
digitBitsIn :: BitSystem s => s -> Int
digitMaskIn :: (BitSystem s, Num α) => s -> α
lastDigitIn :: (BitSystem s, Bits α) => s -> α -> Int
data Binary
Binary :: Binary
data Octal
Octal :: Octal
data Decimal
Decimal :: Decimal
data Hexadecimal
Hexadecimal :: Hexadecimal
data LowHex
LowHex :: LowHex
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
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
printZeroIn :: (PositionalSystem s, Printer p) => s -> p
data Binary
Binary :: Binary
data Octal
Octal :: Octal
data Decimal
Decimal :: Decimal
data Hexadecimal
Hexadecimal :: Hexadecimal
data UpHex
UpHex :: UpHex
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
data Optional
Optional :: Optional
Required :: Optional
isOptional :: Optional -> Bool
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
