    {-# LANGUAGE GeneralizedNewtypeDeriving #-}

    -- | Newtype wrappers for parsers

    module Text.Parser.Wrapper where

    import Control.Applicative (Alternative)
    import Control.Monad (MonadPlus)
    import Text.Parser.Combinators (Parsing)
    import Text.Parser.LookAhead (LookAheadParsing)
    import Text.Parser.Char (CharParsing)
    import Text.Parser.Token (TokenParsing)

    -- | Wrapper that signifies lazy 'Data.ByteString.Lazy.ByteString' inputs
    newtype Lazy   f a = Lazy{forall (f :: * -> *) a. Lazy f a -> f a
    getLazy :: f a} deriving (Lazy f a -> Lazy f a -> Bool
    (Lazy f a -> Lazy f a -> Bool)
    -> (Lazy f a -> Lazy f a -> Bool) -> Eq (Lazy f a)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall (f :: * -> *) a. Eq (f a) => Lazy f a -> Lazy f a -> Bool
    $c== :: forall (f :: * -> *) a. Eq (f a) => Lazy f a -> Lazy f a -> Bool
    == :: Lazy f a -> Lazy f a -> Bool
    $c/= :: forall (f :: * -> *) a. Eq (f a) => Lazy f a -> Lazy f a -> Bool
    /= :: Lazy f a -> Lazy f a -> Bool
    Eq, Eq (Lazy f a)
    Eq (Lazy f a) =>
    (Lazy f a -> Lazy f a -> Ordering)
    -> (Lazy f a -> Lazy f a -> Bool)
    -> (Lazy f a -> Lazy f a -> Bool)
    -> (Lazy f a -> Lazy f a -> Bool)
    -> (Lazy f a -> Lazy f a -> Bool)
    -> (Lazy f a -> Lazy f a -> Lazy f a)
    -> (Lazy f a -> Lazy f a -> Lazy f a)
    -> Ord (Lazy f a)
    Lazy f a -> Lazy f a -> Bool
    Lazy f a -> Lazy f a -> Ordering
    Lazy f a -> Lazy f a -> Lazy f a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall (f :: * -> *) a. Ord (f a) => Eq (Lazy f a)
    forall (f :: * -> *) a. Ord (f a) => Lazy f a -> Lazy f a -> Bool
    forall (f :: * -> *) a.
    Ord (f a) =>
    Lazy f a -> Lazy f a -> Ordering
    forall (f :: * -> *) a.
    Ord (f a) =>
    Lazy f a -> Lazy f a -> Lazy f a
    $ccompare :: forall (f :: * -> *) a.
    Ord (f a) =>
    Lazy f a -> Lazy f a -> Ordering
    compare :: Lazy f a -> Lazy f a -> Ordering
    $c< :: forall (f :: * -> *) a. Ord (f a) => Lazy f a -> Lazy f a -> Bool
    < :: Lazy f a -> Lazy f a -> Bool
    $c<= :: forall (f :: * -> *) a. Ord (f a) => Lazy f a -> Lazy f a -> Bool
    <= :: Lazy f a -> Lazy f a -> Bool
    $c> :: forall (f :: * -> *) a. Ord (f a) => Lazy f a -> Lazy f a -> Bool
    > :: Lazy f a -> Lazy f a -> Bool
    $c>= :: forall (f :: * -> *) a. Ord (f a) => Lazy f a -> Lazy f a -> Bool
    >= :: Lazy f a -> Lazy f a -> Bool
    $cmax :: forall (f :: * -> *) a.
    Ord (f a) =>
    Lazy f a -> Lazy f a -> Lazy f a
    max :: Lazy f a -> Lazy f a -> Lazy f a
    $cmin :: forall (f :: * -> *) a.
    Ord (f a) =>
    Lazy f a -> Lazy f a -> Lazy f a
    min :: Lazy f a -> Lazy f a -> Lazy f a
    Ord, ReadPrec [Lazy f a]
    ReadPrec (Lazy f a)
    Int -> ReadS (Lazy f a)
    ReadS [Lazy f a]
    (Int -> ReadS (Lazy f a))
    -> ReadS [Lazy f a]
    -> ReadPrec (Lazy f a)
    -> ReadPrec [Lazy f a]
    -> Read (Lazy f a)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall (f :: * -> *) a. Read (f a) => ReadPrec [Lazy f a]
    forall (f :: * -> *) a. Read (f a) => ReadPrec (Lazy f a)
    forall (f :: * -> *) a. Read (f a) => Int -> ReadS (Lazy f a)
    forall (f :: * -> *) a. Read (f a) => ReadS [Lazy f a]
    $creadsPrec :: forall (f :: * -> *) a. Read (f a) => Int -> ReadS (Lazy f a)
    readsPrec :: Int -> ReadS (Lazy f a)
    $creadList :: forall (f :: * -> *) a. Read (f a) => ReadS [Lazy f a]
    readList :: ReadS [Lazy f a]
    $creadPrec :: forall (f :: * -> *) a. Read (f a) => ReadPrec (Lazy f a)
    readPrec :: ReadPrec (Lazy f a)
    $creadListPrec :: forall (f :: * -> *) a. Read (f a) => ReadPrec [Lazy f a]
    readListPrec :: ReadPrec [Lazy f a]
    Read, Int -> Lazy f a -> ShowS
    [Lazy f a] -> ShowS
    Lazy f a -> String
    (Int -> Lazy f a -> ShowS)
    -> (Lazy f a -> String) -> ([Lazy f a] -> ShowS) -> Show (Lazy f a)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall (f :: * -> *) a. Show (f a) => Int -> Lazy f a -> ShowS
    forall (f :: * -> *) a. Show (f a) => [Lazy f a] -> ShowS
    forall (f :: * -> *) a. Show (f a) => Lazy f a -> String
    $cshowsPrec :: forall (f :: * -> *) a. Show (f a) => Int -> Lazy f a -> ShowS
    showsPrec :: Int -> Lazy f a -> ShowS
    $cshow :: forall (f :: * -> *) a. Show (f a) => Lazy f a -> String
    show :: Lazy f a -> String
    $cshowList :: forall (f :: * -> *) a. Show (f a) => [Lazy f a] -> ShowS
    showList :: [Lazy f a] -> ShowS
    Show,
                                                        (forall a b. (a -> b) -> Lazy f a -> Lazy f b)
    -> (forall a b. a -> Lazy f b -> Lazy f a) -> Functor (Lazy f)
    forall a b. a -> Lazy f b -> Lazy f a
    forall a b. (a -> b) -> Lazy f a -> Lazy f b
    forall (f :: * -> *) a b. Functor f => a -> Lazy f b -> Lazy f a
    forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> Lazy f a -> Lazy f b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> Lazy f a -> Lazy f b
    fmap :: forall a b. (a -> b) -> Lazy f a -> Lazy f b
    $c<$ :: forall (f :: * -> *) a b. Functor f => a -> Lazy f b -> Lazy f a
    <$ :: forall a b. a -> Lazy f b -> Lazy f a
    Functor, Functor (Lazy f)
    Functor (Lazy f) =>
    (forall a. a -> Lazy f a)
    -> (forall a b. Lazy f (a -> b) -> Lazy f a -> Lazy f b)
    -> (forall a b c.
        (a -> b -> c) -> Lazy f a -> Lazy f b -> Lazy f c)
    -> (forall a b. Lazy f a -> Lazy f b -> Lazy f b)
    -> (forall a b. Lazy f a -> Lazy f b -> Lazy f a)
    -> Applicative (Lazy f)
    forall a. a -> Lazy f a
    forall a b. Lazy f a -> Lazy f b -> Lazy f a
    forall a b. Lazy f a -> Lazy f b -> Lazy f b
    forall a b. Lazy f (a -> b) -> Lazy f a -> Lazy f b
    forall a b c. (a -> b -> c) -> Lazy f a -> Lazy f b -> Lazy f c
    forall (f :: * -> *).
    Functor f =>
    (forall a. a -> f a)
    -> (forall a b. f (a -> b) -> f a -> f b)
    -> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
    -> (forall a b. f a -> f b -> f b)
    -> (forall a b. f a -> f b -> f a)
    -> Applicative f
    forall (f :: * -> *). Applicative f => Functor (Lazy f)
    forall (f :: * -> *) a. Applicative f => a -> Lazy f a
    forall (f :: * -> *) a b.
    Applicative f =>
    Lazy f a -> Lazy f b -> Lazy f a
    forall (f :: * -> *) a b.
    Applicative f =>
    Lazy f a -> Lazy f b -> Lazy f b
    forall (f :: * -> *) a b.
    Applicative f =>
    Lazy f (a -> b) -> Lazy f a -> Lazy f b
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> Lazy f a -> Lazy f b -> Lazy f c
    $cpure :: forall (f :: * -> *) a. Applicative f => a -> Lazy f a
    pure :: forall a. a -> Lazy f a
    $c<*> :: forall (f :: * -> *) a b.
    Applicative f =>
    Lazy f (a -> b) -> Lazy f a -> Lazy f b
    <*> :: forall a b. Lazy f (a -> b) -> Lazy f a -> Lazy f b
    $cliftA2 :: forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> Lazy f a -> Lazy f b -> Lazy f c
    liftA2 :: forall a b c. (a -> b -> c) -> Lazy f a -> Lazy f b -> Lazy f c
    $c*> :: forall (f :: * -> *) a b.
    Applicative f =>
    Lazy f a -> Lazy f b -> Lazy f b
    *> :: forall a b. Lazy f a -> Lazy f b -> Lazy f b
    $c<* :: forall (f :: * -> *) a b.
    Applicative f =>
    Lazy f a -> Lazy f b -> Lazy f a
    <* :: forall a b. Lazy f a -> Lazy f b -> Lazy f a
    Applicative, Applicative (Lazy f)
    Applicative (Lazy f) =>
    (forall a. Lazy f a)
    -> (forall a. Lazy f a -> Lazy f a -> Lazy f a)
    -> (forall a. Lazy f a -> Lazy f [a])
    -> (forall a. Lazy f a -> Lazy f [a])
    -> Alternative (Lazy f)
    forall a. Lazy f a
    forall a. Lazy f a -> Lazy f [a]
    forall a. Lazy f a -> Lazy f a -> Lazy f a
    forall (f :: * -> *).
    Applicative f =>
    (forall a. f a)
    -> (forall a. f a -> f a -> f a)
    -> (forall a. f a -> f [a])
    -> (forall a. f a -> f [a])
    -> Alternative f
    forall (f :: * -> *). Alternative f => Applicative (Lazy f)
    forall (f :: * -> *) a. Alternative f => Lazy f a
    forall (f :: * -> *) a. Alternative f => Lazy f a -> Lazy f [a]
    forall (f :: * -> *) a.
    Alternative f =>
    Lazy f a -> Lazy f a -> Lazy f a
    $cempty :: forall (f :: * -> *) a. Alternative f => Lazy f a
    empty :: forall a. Lazy f a
    $c<|> :: forall (f :: * -> *) a.
    Alternative f =>
    Lazy f a -> Lazy f a -> Lazy f a
    <|> :: forall a. Lazy f a -> Lazy f a -> Lazy f a
    $csome :: forall (f :: * -> *) a. Alternative f => Lazy f a -> Lazy f [a]
    some :: forall a. Lazy f a -> Lazy f [a]
    $cmany :: forall (f :: * -> *) a. Alternative f => Lazy f a -> Lazy f [a]
    many :: forall a. Lazy f a -> Lazy f [a]
    Alternative,
                                                        Applicative (Lazy f)
    Applicative (Lazy f) =>
    (forall a b. Lazy f a -> (a -> Lazy f b) -> Lazy f b)
    -> (forall a b. Lazy f a -> Lazy f b -> Lazy f b)
    -> (forall a. a -> Lazy f a)
    -> Monad (Lazy f)
    forall a. a -> Lazy f a
    forall a b. Lazy f a -> Lazy f b -> Lazy f b
    forall a b. Lazy f a -> (a -> Lazy f b) -> Lazy f b
    forall (f :: * -> *). Monad f => Applicative (Lazy f)
    forall (f :: * -> *) a. Monad f => a -> Lazy f a
    forall (f :: * -> *) a b.
    Monad f =>
    Lazy f a -> Lazy f b -> Lazy f b
    forall (f :: * -> *) a b.
    Monad f =>
    Lazy f a -> (a -> Lazy f b) -> Lazy f b
    forall (m :: * -> *).
    Applicative m =>
    (forall a b. m a -> (a -> m b) -> m b)
    -> (forall a b. m a -> m b -> m b)
    -> (forall a. a -> m a)
    -> Monad m
    $c>>= :: forall (f :: * -> *) a b.
    Monad f =>
    Lazy f a -> (a -> Lazy f b) -> Lazy f b
    >>= :: forall a b. Lazy f a -> (a -> Lazy f b) -> Lazy f b
    $c>> :: forall (f :: * -> *) a b.
    Monad f =>
    Lazy f a -> Lazy f b -> Lazy f b
    >> :: forall a b. Lazy f a -> Lazy f b -> Lazy f b
    $creturn :: forall (f :: * -> *) a. Monad f => a -> Lazy f a
    return :: forall a. a -> Lazy f a
    Monad, Monad (Lazy f)
    Alternative (Lazy f)
    (Alternative (Lazy f), Monad (Lazy f)) =>
    (forall a. Lazy f a)
    -> (forall a. Lazy f a -> Lazy f a -> Lazy f a)
    -> MonadPlus (Lazy f)
    forall a. Lazy f a
    forall a. Lazy f a -> Lazy f a -> Lazy f a
    forall (f :: * -> *). MonadPlus f => Monad (Lazy f)
    forall (f :: * -> *). MonadPlus f => Alternative (Lazy f)
    forall (f :: * -> *) a. MonadPlus f => Lazy f a
    forall (f :: * -> *) a.
    MonadPlus f =>
    Lazy f a -> Lazy f a -> Lazy f a
    forall (m :: * -> *).
    (Alternative m, Monad m) =>
    (forall a. m a) -> (forall a. m a -> m a -> m a) -> MonadPlus m
    $cmzero :: forall (f :: * -> *) a. MonadPlus f => Lazy f a
    mzero :: forall a. Lazy f a
    $cmplus :: forall (f :: * -> *) a.
    MonadPlus f =>
    Lazy f a -> Lazy f a -> Lazy f a
    mplus :: forall a. Lazy f a -> Lazy f a -> Lazy f a
    MonadPlus,
                                                        Alternative (Lazy f)
    Lazy f ()
    Alternative (Lazy f) =>
    (forall a. Lazy f a -> Lazy f a)
    -> (forall a. Lazy f a -> String -> Lazy f a)
    -> (forall a. Lazy f a -> Lazy f ())
    -> (forall a. Lazy f a -> Lazy f ())
    -> (forall a. String -> Lazy f a)
    -> Lazy f ()
    -> (forall a. Show a => Lazy f a -> Lazy f ())
    -> Parsing (Lazy f)
    forall a. Show a => Lazy f a -> Lazy f ()
    forall a. String -> Lazy f a
    forall a. Lazy f a -> Lazy f a
    forall a. Lazy f a -> Lazy f ()
    forall a. Lazy f a -> String -> Lazy f a
    forall (m :: * -> *).
    Alternative m =>
    (forall a. m a -> m a)
    -> (forall a. m a -> String -> m a)
    -> (forall a. m a -> m ())
    -> (forall a. m a -> m ())
    -> (forall a. String -> m a)
    -> m ()
    -> (forall a. Show a => m a -> m ())
    -> Parsing m
    forall (f :: * -> *). Parsing f => Alternative (Lazy f)
    forall (f :: * -> *). Parsing f => Lazy f ()
    forall (f :: * -> *) a.
    (Parsing f, Show a) =>
    Lazy f a -> Lazy f ()
    forall (f :: * -> *) a. Parsing f => String -> Lazy f a
    forall (f :: * -> *) a. Parsing f => Lazy f a -> Lazy f a
    forall (f :: * -> *) a. Parsing f => Lazy f a -> Lazy f ()
    forall (f :: * -> *) a. Parsing f => Lazy f a -> String -> Lazy f a
    $ctry :: forall (f :: * -> *) a. Parsing f => Lazy f a -> Lazy f a
    try :: forall a. Lazy f a -> Lazy f a
    $c<?> :: forall (f :: * -> *) a. Parsing f => Lazy f a -> String -> Lazy f a
    <?> :: forall a. Lazy f a -> String -> Lazy f a
    $cskipMany :: forall (f :: * -> *) a. Parsing f => Lazy f a -> Lazy f ()
    skipMany :: forall a. Lazy f a -> Lazy f ()
    $cskipSome :: forall (f :: * -> *) a. Parsing f => Lazy f a -> Lazy f ()
    skipSome :: forall a. Lazy f a -> Lazy f ()
    $cunexpected :: forall (f :: * -> *) a. Parsing f => String -> Lazy f a
    unexpected :: forall a. String -> Lazy f a
    $ceof :: forall (f :: * -> *). Parsing f => Lazy f ()
    eof :: Lazy f ()
    $cnotFollowedBy :: forall (f :: * -> *) a.
    (Parsing f, Show a) =>
    Lazy f a -> Lazy f ()
    notFollowedBy :: forall a. Show a => Lazy f a -> Lazy f ()
    Parsing, Parsing (Lazy f)
    Parsing (Lazy f) =>
    (forall a. Lazy f a -> Lazy f a) -> LookAheadParsing (Lazy f)
    forall a. Lazy f a -> Lazy f a
    forall (m :: * -> *).
    Parsing m =>
    (forall a. m a -> m a) -> LookAheadParsing m
    forall (f :: * -> *). LookAheadParsing f => Parsing (Lazy f)
    forall (f :: * -> *) a. LookAheadParsing f => Lazy f a -> Lazy f a
    $clookAhead :: forall (f :: * -> *) a. LookAheadParsing f => Lazy f a -> Lazy f a
    lookAhead :: forall a. Lazy f a -> Lazy f a
    LookAheadParsing, Parsing (Lazy f)
    Lazy f Char
    Char -> Lazy f Char
    String -> Lazy f String
    Text -> Lazy f Text
    Parsing (Lazy f) =>
    ((Char -> Bool) -> Lazy f Char)
    -> (Char -> Lazy f Char)
    -> (Char -> Lazy f Char)
    -> Lazy f Char
    -> (String -> Lazy f String)
    -> (Text -> Lazy f Text)
    -> CharParsing (Lazy f)
    (Char -> Bool) -> Lazy f Char
    forall (m :: * -> *).
    Parsing m =>
    ((Char -> Bool) -> m Char)
    -> (Char -> m Char)
    -> (Char -> m Char)
    -> m Char
    -> (String -> m String)
    -> (Text -> m Text)
    -> CharParsing m
    forall (f :: * -> *). CharParsing f => Parsing (Lazy f)
    forall (f :: * -> *). CharParsing f => Lazy f Char
    forall (f :: * -> *). CharParsing f => Char -> Lazy f Char
    forall (f :: * -> *). CharParsing f => String -> Lazy f String
    forall (f :: * -> *). CharParsing f => Text -> Lazy f Text
    forall (f :: * -> *).
    CharParsing f =>
    (Char -> Bool) -> Lazy f Char
    $csatisfy :: forall (f :: * -> *).
    CharParsing f =>
    (Char -> Bool) -> Lazy f Char
    satisfy :: (Char -> Bool) -> Lazy f Char
    $cchar :: forall (f :: * -> *). CharParsing f => Char -> Lazy f Char
    char :: Char -> Lazy f Char
    $cnotChar :: forall (f :: * -> *). CharParsing f => Char -> Lazy f Char
    notChar :: Char -> Lazy f Char
    $canyChar :: forall (f :: * -> *). CharParsing f => Lazy f Char
    anyChar :: Lazy f Char
    $cstring :: forall (f :: * -> *). CharParsing f => String -> Lazy f String
    string :: String -> Lazy f String
    $ctext :: forall (f :: * -> *). CharParsing f => Text -> Lazy f Text
    text :: Text -> Lazy f Text
    CharParsing, CharParsing (Lazy f)
    Lazy f Char
    Lazy f ()
    CharParsing (Lazy f) =>
    Lazy f ()
    -> (forall a. Lazy f a -> Lazy f a)
    -> Lazy f Char
    -> (forall a. Highlight -> Lazy f a -> Lazy f a)
    -> (forall a. Lazy f a -> Lazy f a)
    -> TokenParsing (Lazy f)
    forall a. Highlight -> Lazy f a -> Lazy f a
    forall a. Lazy f a -> Lazy f a
    forall (m :: * -> *).
    CharParsing m =>
    m ()
    -> (forall a. m a -> m a)
    -> m Char
    -> (forall a. Highlight -> m a -> m a)
    -> (forall a. m a -> m a)
    -> TokenParsing m
    forall (f :: * -> *). TokenParsing f => CharParsing (Lazy f)
    forall (f :: * -> *). TokenParsing f => Lazy f Char
    forall (f :: * -> *). TokenParsing f => Lazy f ()
    forall (f :: * -> *) a.
    TokenParsing f =>
    Highlight -> Lazy f a -> Lazy f a
    forall (f :: * -> *) a. TokenParsing f => Lazy f a -> Lazy f a
    $csomeSpace :: forall (f :: * -> *). TokenParsing f => Lazy f ()
    someSpace :: Lazy f ()
    $cnesting :: forall (f :: * -> *) a. TokenParsing f => Lazy f a -> Lazy f a
    nesting :: forall a. Lazy f a -> Lazy f a
    $csemi :: forall (f :: * -> *). TokenParsing f => Lazy f Char
    semi :: Lazy f Char
    $chighlight :: forall (f :: * -> *) a.
    TokenParsing f =>
    Highlight -> Lazy f a -> Lazy f a
    highlight :: forall a. Highlight -> Lazy f a -> Lazy f a
    $ctoken :: forall (f :: * -> *) a. TokenParsing f => Lazy f a -> Lazy f a
    token :: forall a. Lazy f a -> Lazy f a
    TokenParsing)
    -- | Wrapper that signifies strict 'Data.ByteString.ByteString' inputs
    newtype Strict f a = Strict{forall (f :: * -> *) a. Strict f a -> f a
    getStrict :: f a} deriving (Strict f a -> Strict f a -> Bool
    (Strict f a -> Strict f a -> Bool)
    -> (Strict f a -> Strict f a -> Bool) -> Eq (Strict f a)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall (f :: * -> *) a.
    Eq (f a) =>
    Strict f a -> Strict f a -> Bool
    $c== :: forall (f :: * -> *) a.
    Eq (f a) =>
    Strict f a -> Strict f a -> Bool
    == :: Strict f a -> Strict f a -> Bool
    $c/= :: forall (f :: * -> *) a.
    Eq (f a) =>
    Strict f a -> Strict f a -> Bool
    /= :: Strict f a -> Strict f a -> Bool
    Eq, Eq (Strict f a)
    Eq (Strict f a) =>
    (Strict f a -> Strict f a -> Ordering)
    -> (Strict f a -> Strict f a -> Bool)
    -> (Strict f a -> Strict f a -> Bool)
    -> (Strict f a -> Strict f a -> Bool)
    -> (Strict f a -> Strict f a -> Bool)
    -> (Strict f a -> Strict f a -> Strict f a)
    -> (Strict f a -> Strict f a -> Strict f a)
    -> Ord (Strict f a)
    Strict f a -> Strict f a -> Bool
    Strict f a -> Strict f a -> Ordering
    Strict f a -> Strict f a -> Strict f a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall (f :: * -> *) a. Ord (f a) => Eq (Strict f a)
    forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Bool
    forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Ordering
    forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Strict f a
    $ccompare :: forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Ordering
    compare :: Strict f a -> Strict f a -> Ordering
    $c< :: forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Bool
    < :: Strict f a -> Strict f a -> Bool
    $c<= :: forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Bool
    <= :: Strict f a -> Strict f a -> Bool
    $c> :: forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Bool
    > :: Strict f a -> Strict f a -> Bool
    $c>= :: forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Bool
    >= :: Strict f a -> Strict f a -> Bool
    $cmax :: forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Strict f a
    max :: Strict f a -> Strict f a -> Strict f a
    $cmin :: forall (f :: * -> *) a.
    Ord (f a) =>
    Strict f a -> Strict f a -> Strict f a
    min :: Strict f a -> Strict f a -> Strict f a
    Ord, ReadPrec [Strict f a]
    ReadPrec (Strict f a)
    Int -> ReadS (Strict f a)
    ReadS [Strict f a]
    (Int -> ReadS (Strict f a))
    -> ReadS [Strict f a]
    -> ReadPrec (Strict f a)
    -> ReadPrec [Strict f a]
    -> Read (Strict f a)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall (f :: * -> *) a. Read (f a) => ReadPrec [Strict f a]
    forall (f :: * -> *) a. Read (f a) => ReadPrec (Strict f a)
    forall (f :: * -> *) a. Read (f a) => Int -> ReadS (Strict f a)
    forall (f :: * -> *) a. Read (f a) => ReadS [Strict f a]
    $creadsPrec :: forall (f :: * -> *) a. Read (f a) => Int -> ReadS (Strict f a)
    readsPrec :: Int -> ReadS (Strict f a)
    $creadList :: forall (f :: * -> *) a. Read (f a) => ReadS [Strict f a]
    readList :: ReadS [Strict f a]
    $creadPrec :: forall (f :: * -> *) a. Read (f a) => ReadPrec (Strict f a)
    readPrec :: ReadPrec (Strict f a)
    $creadListPrec :: forall (f :: * -> *) a. Read (f a) => ReadPrec [Strict f a]
    readListPrec :: ReadPrec [Strict f a]
    Read, Int -> Strict f a -> ShowS
    [Strict f a] -> ShowS
    Strict f a -> String
    (Int -> Strict f a -> ShowS)
    -> (Strict f a -> String)
    -> ([Strict f a] -> ShowS)
    -> Show (Strict f a)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall (f :: * -> *) a. Show (f a) => Int -> Strict f a -> ShowS
    forall (f :: * -> *) a. Show (f a) => [Strict f a] -> ShowS
    forall (f :: * -> *) a. Show (f a) => Strict f a -> String
    $cshowsPrec :: forall (f :: * -> *) a. Show (f a) => Int -> Strict f a -> ShowS
    showsPrec :: Int -> Strict f a -> ShowS
    $cshow :: forall (f :: * -> *) a. Show (f a) => Strict f a -> String
    show :: Strict f a -> String
    $cshowList :: forall (f :: * -> *) a. Show (f a) => [Strict f a] -> ShowS
    showList :: [Strict f a] -> ShowS
    Show,
                                                            (forall a b. (a -> b) -> Strict f a -> Strict f b)
    -> (forall a b. a -> Strict f b -> Strict f a)
    -> Functor (Strict f)
    forall a b. a -> Strict f b -> Strict f a
    forall a b. (a -> b) -> Strict f a -> Strict f b
    forall (f :: * -> *) a b.
    Functor f =>
    a -> Strict f b -> Strict f a
    forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> Strict f a -> Strict f b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> Strict f a -> Strict f b
    fmap :: forall a b. (a -> b) -> Strict f a -> Strict f b
    $c<$ :: forall (f :: * -> *) a b.
    Functor f =>
    a -> Strict f b -> Strict f a
    <$ :: forall a b. a -> Strict f b -> Strict f a
    Functor, Functor (Strict f)
    Functor (Strict f) =>
    (forall a. a -> Strict f a)
    -> (forall a b. Strict f (a -> b) -> Strict f a -> Strict f b)
    -> (forall a b c.
        (a -> b -> c) -> Strict f a -> Strict f b -> Strict f c)
    -> (forall a b. Strict f a -> Strict f b -> Strict f b)
    -> (forall a b. Strict f a -> Strict f b -> Strict f a)
    -> Applicative (Strict f)
    forall a. a -> Strict f a
    forall a b. Strict f a -> Strict f b -> Strict f a
    forall a b. Strict f a -> Strict f b -> Strict f b
    forall a b. Strict f (a -> b) -> Strict f a -> Strict f b
    forall a b c.
    (a -> b -> c) -> Strict f a -> Strict f b -> Strict f c
    forall (f :: * -> *).
    Functor f =>
    (forall a. a -> f a)
    -> (forall a b. f (a -> b) -> f a -> f b)
    -> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
    -> (forall a b. f a -> f b -> f b)
    -> (forall a b. f a -> f b -> f a)
    -> Applicative f
    forall (f :: * -> *). Applicative f => Functor (Strict f)
    forall (f :: * -> *) a. Applicative f => a -> Strict f a
    forall (f :: * -> *) a b.
    Applicative f =>
    Strict f a -> Strict f b -> Strict f a
    forall (f :: * -> *) a b.
    Applicative f =>
    Strict f a -> Strict f b -> Strict f b
    forall (f :: * -> *) a b.
    Applicative f =>
    Strict f (a -> b) -> Strict f a -> Strict f b
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> Strict f a -> Strict f b -> Strict f c
    $cpure :: forall (f :: * -> *) a. Applicative f => a -> Strict f a
    pure :: forall a. a -> Strict f a
    $c<*> :: forall (f :: * -> *) a b.
    Applicative f =>
    Strict f (a -> b) -> Strict f a -> Strict f b
    <*> :: forall a b. Strict f (a -> b) -> Strict f a -> Strict f b
    $cliftA2 :: forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> Strict f a -> Strict f b -> Strict f c
    liftA2 :: forall a b c.
    (a -> b -> c) -> Strict f a -> Strict f b -> Strict f c
    $c*> :: forall (f :: * -> *) a b.
    Applicative f =>
    Strict f a -> Strict f b -> Strict f b
    *> :: forall a b. Strict f a -> Strict f b -> Strict f b
    $c<* :: forall (f :: * -> *) a b.
    Applicative f =>
    Strict f a -> Strict f b -> Strict f a
    <* :: forall a b. Strict f a -> Strict f b -> Strict f a
    Applicative, Applicative (Strict f)
    Applicative (Strict f) =>
    (forall a. Strict f a)
    -> (forall a. Strict f a -> Strict f a -> Strict f a)
    -> (forall a. Strict f a -> Strict f [a])
    -> (forall a. Strict f a -> Strict f [a])
    -> Alternative (Strict f)
    forall a. Strict f a
    forall a. Strict f a -> Strict f [a]
    forall a. Strict f a -> Strict f a -> Strict f a
    forall (f :: * -> *).
    Applicative f =>
    (forall a. f a)
    -> (forall a. f a -> f a -> f a)
    -> (forall a. f a -> f [a])
    -> (forall a. f a -> f [a])
    -> Alternative f
    forall (f :: * -> *). Alternative f => Applicative (Strict f)
    forall (f :: * -> *) a. Alternative f => Strict f a
    forall (f :: * -> *) a. Alternative f => Strict f a -> Strict f [a]
    forall (f :: * -> *) a.
    Alternative f =>
    Strict f a -> Strict f a -> Strict f a
    $cempty :: forall (f :: * -> *) a. Alternative f => Strict f a
    empty :: forall a. Strict f a
    $c<|> :: forall (f :: * -> *) a.
    Alternative f =>
    Strict f a -> Strict f a -> Strict f a
    <|> :: forall a. Strict f a -> Strict f a -> Strict f a
    $csome :: forall (f :: * -> *) a. Alternative f => Strict f a -> Strict f [a]
    some :: forall a. Strict f a -> Strict f [a]
    $cmany :: forall (f :: * -> *) a. Alternative f => Strict f a -> Strict f [a]
    many :: forall a. Strict f a -> Strict f [a]
    Alternative,
                                                            Applicative (Strict f)
    Applicative (Strict f) =>
    (forall a b. Strict f a -> (a -> Strict f b) -> Strict f b)
    -> (forall a b. Strict f a -> Strict f b -> Strict f b)
    -> (forall a. a -> Strict f a)
    -> Monad (Strict f)
    forall a. a -> Strict f a
    forall a b. Strict f a -> Strict f b -> Strict f b
    forall a b. Strict f a -> (a -> Strict f b) -> Strict f b
    forall (f :: * -> *). Monad f => Applicative (Strict f)
    forall (f :: * -> *) a. Monad f => a -> Strict f a
    forall (f :: * -> *) a b.
    Monad f =>
    Strict f a -> Strict f b -> Strict f b
    forall (f :: * -> *) a b.
    Monad f =>
    Strict f a -> (a -> Strict f b) -> Strict f b
    forall (m :: * -> *).
    Applicative m =>
    (forall a b. m a -> (a -> m b) -> m b)
    -> (forall a b. m a -> m b -> m b)
    -> (forall a. a -> m a)
    -> Monad m
    $c>>= :: forall (f :: * -> *) a b.
    Monad f =>
    Strict f a -> (a -> Strict f b) -> Strict f b
    >>= :: forall a b. Strict f a -> (a -> Strict f b) -> Strict f b
    $c>> :: forall (f :: * -> *) a b.
    Monad f =>
    Strict f a -> Strict f b -> Strict f b
    >> :: forall a b. Strict f a -> Strict f b -> Strict f b
    $creturn :: forall (f :: * -> *) a. Monad f => a -> Strict f a
    return :: forall a. a -> Strict f a
    Monad, Monad (Strict f)
    Alternative (Strict f)
    (Alternative (Strict f), Monad (Strict f)) =>
    (forall a. Strict f a)
    -> (forall a. Strict f a -> Strict f a -> Strict f a)
    -> MonadPlus (Strict f)
    forall a. Strict f a
    forall a. Strict f a -> Strict f a -> Strict f a
    forall (f :: * -> *). MonadPlus f => Monad (Strict f)
    forall (f :: * -> *). MonadPlus f => Alternative (Strict f)
    forall (f :: * -> *) a. MonadPlus f => Strict f a
    forall (f :: * -> *) a.
    MonadPlus f =>
    Strict f a -> Strict f a -> Strict f a
    forall (m :: * -> *).
    (Alternative m, Monad m) =>
    (forall a. m a) -> (forall a. m a -> m a -> m a) -> MonadPlus m
    $cmzero :: forall (f :: * -> *) a. MonadPlus f => Strict f a
    mzero :: forall a. Strict f a
    $cmplus :: forall (f :: * -> *) a.
    MonadPlus f =>
    Strict f a -> Strict f a -> Strict f a
    mplus :: forall a. Strict f a -> Strict f a -> Strict f a
    MonadPlus,
                                                            Alternative (Strict f)
    Strict f ()
    Alternative (Strict f) =>
    (forall a. Strict f a -> Strict f a)
    -> (forall a. Strict f a -> String -> Strict f a)
    -> (forall a. Strict f a -> Strict f ())
    -> (forall a. Strict f a -> Strict f ())
    -> (forall a. String -> Strict f a)
    -> Strict f ()
    -> (forall a. Show a => Strict f a -> Strict f ())
    -> Parsing (Strict f)
    forall a. Show a => Strict f a -> Strict f ()
    forall a. String -> Strict f a
    forall a. Strict f a -> Strict f a
    forall a. Strict f a -> Strict f ()
    forall a. Strict f a -> String -> Strict f a
    forall (m :: * -> *).
    Alternative m =>
    (forall a. m a -> m a)
    -> (forall a. m a -> String -> m a)
    -> (forall a. m a -> m ())
    -> (forall a. m a -> m ())
    -> (forall a. String -> m a)
    -> m ()
    -> (forall a. Show a => m a -> m ())
    -> Parsing m
    forall (f :: * -> *). Parsing f => Alternative (Strict f)
    forall (f :: * -> *). Parsing f => Strict f ()
    forall (f :: * -> *) a.
    (Parsing f, Show a) =>
    Strict f a -> Strict f ()
    forall (f :: * -> *) a. Parsing f => String -> Strict f a
    forall (f :: * -> *) a. Parsing f => Strict f a -> Strict f a
    forall (f :: * -> *) a. Parsing f => Strict f a -> Strict f ()
    forall (f :: * -> *) a.
    Parsing f =>
    Strict f a -> String -> Strict f a
    $ctry :: forall (f :: * -> *) a. Parsing f => Strict f a -> Strict f a
    try :: forall a. Strict f a -> Strict f a
    $c<?> :: forall (f :: * -> *) a.
    Parsing f =>
    Strict f a -> String -> Strict f a
    <?> :: forall a. Strict f a -> String -> Strict f a
    $cskipMany :: forall (f :: * -> *) a. Parsing f => Strict f a -> Strict f ()
    skipMany :: forall a. Strict f a -> Strict f ()
    $cskipSome :: forall (f :: * -> *) a. Parsing f => Strict f a -> Strict f ()
    skipSome :: forall a. Strict f a -> Strict f ()
    $cunexpected :: forall (f :: * -> *) a. Parsing f => String -> Strict f a
    unexpected :: forall a. String -> Strict f a
    $ceof :: forall (f :: * -> *). Parsing f => Strict f ()
    eof :: Strict f ()
    $cnotFollowedBy :: forall (f :: * -> *) a.
    (Parsing f, Show a) =>
    Strict f a -> Strict f ()
    notFollowedBy :: forall a. Show a => Strict f a -> Strict f ()
    Parsing, Parsing (Strict f)
    Parsing (Strict f) =>
    (forall a. Strict f a -> Strict f a) -> LookAheadParsing (Strict f)
    forall a. Strict f a -> Strict f a
    forall (m :: * -> *).
    Parsing m =>
    (forall a. m a -> m a) -> LookAheadParsing m
    forall (f :: * -> *). LookAheadParsing f => Parsing (Strict f)
    forall (f :: * -> *) a.
    LookAheadParsing f =>
    Strict f a -> Strict f a
    $clookAhead :: forall (f :: * -> *) a.
    LookAheadParsing f =>
    Strict f a -> Strict f a
    lookAhead :: forall a. Strict f a -> Strict f a
    LookAheadParsing, Parsing (Strict f)
    Strict f Char
    Char -> Strict f Char
    String -> Strict f String
    Text -> Strict f Text
    Parsing (Strict f) =>
    ((Char -> Bool) -> Strict f Char)
    -> (Char -> Strict f Char)
    -> (Char -> Strict f Char)
    -> Strict f Char
    -> (String -> Strict f String)
    -> (Text -> Strict f Text)
    -> CharParsing (Strict f)
    (Char -> Bool) -> Strict f Char
    forall (m :: * -> *).
    Parsing m =>
    ((Char -> Bool) -> m Char)
    -> (Char -> m Char)
    -> (Char -> m Char)
    -> m Char
    -> (String -> m String)
    -> (Text -> m Text)
    -> CharParsing m
    forall (f :: * -> *). CharParsing f => Parsing (Strict f)
    forall (f :: * -> *). CharParsing f => Strict f Char
    forall (f :: * -> *). CharParsing f => Char -> Strict f Char
    forall (f :: * -> *). CharParsing f => String -> Strict f String
    forall (f :: * -> *). CharParsing f => Text -> Strict f Text
    forall (f :: * -> *).
    CharParsing f =>
    (Char -> Bool) -> Strict f Char
    $csatisfy :: forall (f :: * -> *).
    CharParsing f =>
    (Char -> Bool) -> Strict f Char
    satisfy :: (Char -> Bool) -> Strict f Char
    $cchar :: forall (f :: * -> *). CharParsing f => Char -> Strict f Char
    char :: Char -> Strict f Char
    $cnotChar :: forall (f :: * -> *). CharParsing f => Char -> Strict f Char
    notChar :: Char -> Strict f Char
    $canyChar :: forall (f :: * -> *). CharParsing f => Strict f Char
    anyChar :: Strict f Char
    $cstring :: forall (f :: * -> *). CharParsing f => String -> Strict f String
    string :: String -> Strict f String
    $ctext :: forall (f :: * -> *). CharParsing f => Text -> Strict f Text
    text :: Text -> Strict f Text
    CharParsing, CharParsing (Strict f)
    Strict f Char
    Strict f ()
    CharParsing (Strict f) =>
    Strict f ()
    -> (forall a. Strict f a -> Strict f a)
    -> Strict f Char
    -> (forall a. Highlight -> Strict f a -> Strict f a)
    -> (forall a. Strict f a -> Strict f a)
    -> TokenParsing (Strict f)
    forall a. Highlight -> Strict f a -> Strict f a
    forall a. Strict f a -> Strict f a
    forall (m :: * -> *).
    CharParsing m =>
    m ()
    -> (forall a. m a -> m a)
    -> m Char
    -> (forall a. Highlight -> m a -> m a)
    -> (forall a. m a -> m a)
    -> TokenParsing m
    forall (f :: * -> *). TokenParsing f => CharParsing (Strict f)
    forall (f :: * -> *). TokenParsing f => Strict f Char
    forall (f :: * -> *). TokenParsing f => Strict f ()
    forall (f :: * -> *) a.
    TokenParsing f =>
    Highlight -> Strict f a -> Strict f a
    forall (f :: * -> *) a. TokenParsing f => Strict f a -> Strict f a
    $csomeSpace :: forall (f :: * -> *). TokenParsing f => Strict f ()
    someSpace :: Strict f ()
    $cnesting :: forall (f :: * -> *) a. TokenParsing f => Strict f a -> Strict f a
    nesting :: forall a. Strict f a -> Strict f a
    $csemi :: forall (f :: * -> *). TokenParsing f => Strict f Char
    semi :: Strict f Char
    $chighlight :: forall (f :: * -> *) a.
    TokenParsing f =>
    Highlight -> Strict f a -> Strict f a
    highlight :: forall a. Highlight -> Strict f a -> Strict f a
    $ctoken :: forall (f :: * -> *) a. TokenParsing f => Strict f a -> Strict f a
    token :: forall a. Strict f a -> Strict f a
    TokenParsing)