    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveFoldable     #-}
    {-# LANGUAGE FlexibleInstances  #-}
    {-# OPTIONS_HADDOCK show-extensions #-}

    -- |
    -- Module      :  Yi.Syntax.JavaScript
    -- License     :  GPL-2
    -- Maintainer  :  yi-devel@googlegroups.com
    -- Stability   :  experimental
    -- Portability :  portable
    --
    -- Parser for the JavaScript language as described at
    -- <http://publications.lib.chalmers.se/records/fulltext/112284.pdf Dogan 2009>.
    --
    -- The mode using this parser can be found at "Yi.Mode.JavaScript".

    module Yi.Syntax.JavaScript where

    import           Prelude hiding (elem,error,any,exp)
    import qualified Prelude

    import           Control.Applicative (Alternative ((<|>), many), optional)
    import           Data.Data           (Data)
    import           Data.Foldable       (any, elem, toList)
    import           Data.Monoid         (Endo (..), (<>))
    import qualified Data.Text           as T (cons)
    import           Data.Typeable       (Typeable)
    import           Yi.Buffer.Basic     (Point (..))
    import           Yi.Debug            (trace)
    import           Yi.IncrementalParse (P, eof, recoverWith, symbol)
    import           Yi.Lexer.Alex       (Stroke, Tok (..), tokFromT, tokToSpan)
    import           Yi.Lexer.JavaScript
    import           Yi.String           (showT)
    import           Yi.Style            (StyleName, errorStyle)
    import           Yi.Syntax.Tree      (IsTree (..), sepBy, sepBy1)

    -- * Data types, classes and instances

    -- | Instances of @Strokable@ are datatypes which can be syntax highlighted.
    class Strokable a where
        toStrokes :: a -> Endo [Stroke]

    -- | Instances of @Failable@ can represent failure.  This is a useful class for
    --   future work, since then we can make stroking much easier.
    class Failable f where
        stupid :: t -> f t
        hasFailed :: f t -> Bool

    type BList a = [a]

    type Tree t = BList (Statement t)

    type Semicolon t = Maybe t

    data Statement t = FunDecl t t (Parameters t) (Block t)
                     | VarDecl t (BList (VarDecAss t)) (Semicolon t)
                     | Return t (Maybe (Expr t)) (Semicolon t)
                     | While t (ParExpr t) (Block t)
                     | DoWhile t (Block t) t (ParExpr t) (Semicolon t)
                     | For t t (Expr t) (ForContent t) t (Block t)
                     | If t (ParExpr t) (Block t) (Maybe (Statement t))
                     | Else t (Block t)
                     | With t (ParExpr t) (Block t)
                     | Comm t
                     | Expr (Expr t) (Semicolon t)
                       deriving (Int -> Statement t -> ShowS
    [Statement t] -> ShowS
    Statement t -> String
    (Int -> Statement t -> ShowS)
    -> (Statement t -> String)
    -> ([Statement t] -> ShowS)
    -> Show (Statement t)
    forall t. Show t => Int -> Statement t -> ShowS
    forall t. Show t => [Statement t] -> ShowS
    forall t. Show t => Statement t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> Statement t -> ShowS
    showsPrec :: Int -> Statement t -> ShowS
    $cshow :: forall t. Show t => Statement t -> String
    show :: Statement t -> String
    $cshowList :: forall t. Show t => [Statement t] -> ShowS
    showList :: [Statement t] -> ShowS
    Show, Typeable (Statement t)
    Typeable (Statement t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Statement t -> c (Statement t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Statement t))
    -> (Statement t -> Constr)
    -> (Statement t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Statement t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Statement t)))
    -> ((forall b. Data b => b -> b) -> Statement t -> Statement t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Statement t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Statement t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Statement t -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Statement t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Statement t -> m (Statement t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Statement t -> m (Statement t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Statement t -> m (Statement t))
    -> Data (Statement t)
    Statement t -> Constr
    Statement t -> DataType
    (forall b. Data b => b -> b) -> Statement t -> Statement t
    forall t. Data t => Typeable (Statement t)
    forall t. Data t => Statement t -> Constr
    forall t. Data t => Statement t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Statement t -> Statement t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Statement t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> Statement t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Statement t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Statement t -> c (Statement t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Statement t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Statement t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Statement t -> u
    forall u. (forall d. Data d => d -> u) -> Statement t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Statement t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Statement t -> c (Statement t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Statement t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Statement t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Statement t -> c (Statement t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Statement t -> c (Statement t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Statement t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Statement t)
    $ctoConstr :: forall t. Data t => Statement t -> Constr
    toConstr :: Statement t -> Constr
    $cdataTypeOf :: forall t. Data t => Statement t -> DataType
    dataTypeOf :: Statement t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Statement t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Statement t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Statement t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Statement t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Statement t -> Statement t
    gmapT :: (forall b. Data b => b -> b) -> Statement t -> Statement t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Statement t -> r
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> Statement t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Statement t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Statement t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Statement t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Statement t -> m (Statement t)
    Data, Typeable, (forall m. Monoid m => Statement m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Statement a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Statement a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Statement a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Statement a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Statement a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Statement a -> b)
    -> (forall a. (a -> a -> a) -> Statement a -> a)
    -> (forall a. (a -> a -> a) -> Statement a -> a)
    -> (forall a. Statement a -> [a])
    -> (forall a. Statement a -> Bool)
    -> (forall a. Statement a -> Int)
    -> (forall a. Eq a => a -> Statement a -> Bool)
    -> (forall a. Ord a => Statement a -> a)
    -> (forall a. Ord a => Statement a -> a)
    -> (forall a. Num a => Statement a -> a)
    -> (forall a. Num a => Statement a -> a)
    -> Foldable Statement
    forall a. Eq a => a -> Statement a -> Bool
    forall a. Num a => Statement a -> a
    forall a. Ord a => Statement a -> a
    forall m. Monoid m => Statement m -> m
    forall a. Statement a -> Bool
    forall a. Statement a -> Int
    forall a. Statement a -> [a]
    forall a. (a -> a -> a) -> Statement a -> a
    forall m a. Monoid m => (a -> m) -> Statement a -> m
    forall b a. (b -> a -> b) -> b -> Statement a -> b
    forall a b. (a -> b -> b) -> b -> Statement a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Statement m -> m
    fold :: forall m. Monoid m => Statement m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Statement a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Statement a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Statement a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Statement a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Statement a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Statement a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Statement a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Statement a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Statement a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Statement a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Statement a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Statement a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Statement a -> a
    foldr1 :: forall a. (a -> a -> a) -> Statement a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Statement a -> a
    foldl1 :: forall a. (a -> a -> a) -> Statement a -> a
    $ctoList :: forall a. Statement a -> [a]
    toList :: forall a. Statement a -> [a]
    $cnull :: forall a. Statement a -> Bool
    null :: forall a. Statement a -> Bool
    $clength :: forall a. Statement a -> Int
    length :: forall a. Statement a -> Int
    $celem :: forall a. Eq a => a -> Statement a -> Bool
    elem :: forall a. Eq a => a -> Statement a -> Bool
    $cmaximum :: forall a. Ord a => Statement a -> a
    maximum :: forall a. Ord a => Statement a -> a
    $cminimum :: forall a. Ord a => Statement a -> a
    minimum :: forall a. Ord a => Statement a -> a
    $csum :: forall a. Num a => Statement a -> a
    sum :: forall a. Num a => Statement a -> a
    $cproduct :: forall a. Num a => Statement a -> a
    product :: forall a. Num a => Statement a -> a
    Foldable)

    data Parameters t = Parameters t (BList t) t
                      | ParErr t
                        deriving (Int -> Parameters t -> ShowS
    [Parameters t] -> ShowS
    Parameters t -> String
    (Int -> Parameters t -> ShowS)
    -> (Parameters t -> String)
    -> ([Parameters t] -> ShowS)
    -> Show (Parameters t)
    forall t. Show t => Int -> Parameters t -> ShowS
    forall t. Show t => [Parameters t] -> ShowS
    forall t. Show t => Parameters t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> Parameters t -> ShowS
    showsPrec :: Int -> Parameters t -> ShowS
    $cshow :: forall t. Show t => Parameters t -> String
    show :: Parameters t -> String
    $cshowList :: forall t. Show t => [Parameters t] -> ShowS
    showList :: [Parameters t] -> ShowS
    Show, Typeable (Parameters t)
    Typeable (Parameters t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Parameters t -> c (Parameters t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Parameters t))
    -> (Parameters t -> Constr)
    -> (Parameters t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Parameters t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (Parameters t)))
    -> ((forall b. Data b => b -> b) -> Parameters t -> Parameters t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Parameters t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Parameters t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Parameters t -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> Parameters t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t))
    -> Data (Parameters t)
    Parameters t -> Constr
    Parameters t -> DataType
    (forall b. Data b => b -> b) -> Parameters t -> Parameters t
    forall t. Data t => Typeable (Parameters t)
    forall t. Data t => Parameters t -> Constr
    forall t. Data t => Parameters t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Parameters t -> Parameters t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Parameters t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> Parameters t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameters t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameters t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Parameters t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Parameters t -> c (Parameters t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Parameters t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Parameters t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Parameters t -> u
    forall u. (forall d. Data d => d -> u) -> Parameters t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameters t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameters t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Parameters t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Parameters t -> c (Parameters t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Parameters t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Parameters t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Parameters t -> c (Parameters t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Parameters t -> c (Parameters t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Parameters t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Parameters t)
    $ctoConstr :: forall t. Data t => Parameters t -> Constr
    toConstr :: Parameters t -> Constr
    $cdataTypeOf :: forall t. Data t => Parameters t -> DataType
    dataTypeOf :: Parameters t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Parameters t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Parameters t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Parameters t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Parameters t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Parameters t -> Parameters t
    gmapT :: (forall b. Data b => b -> b) -> Parameters t -> Parameters t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameters t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameters t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameters t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Parameters t -> r
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> Parameters t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Parameters t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Parameters t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Parameters t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Parameters t -> m (Parameters t)
    Data, Typeable, (forall m. Monoid m => Parameters m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Parameters a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Parameters a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Parameters a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Parameters a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Parameters a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Parameters a -> b)
    -> (forall a. (a -> a -> a) -> Parameters a -> a)
    -> (forall a. (a -> a -> a) -> Parameters a -> a)
    -> (forall a. Parameters a -> [a])
    -> (forall a. Parameters a -> Bool)
    -> (forall a. Parameters a -> Int)
    -> (forall a. Eq a => a -> Parameters a -> Bool)
    -> (forall a. Ord a => Parameters a -> a)
    -> (forall a. Ord a => Parameters a -> a)
    -> (forall a. Num a => Parameters a -> a)
    -> (forall a. Num a => Parameters a -> a)
    -> Foldable Parameters
    forall a. Eq a => a -> Parameters a -> Bool
    forall a. Num a => Parameters a -> a
    forall a. Ord a => Parameters a -> a
    forall m. Monoid m => Parameters m -> m
    forall a. Parameters a -> Bool
    forall a. Parameters a -> Int
    forall a. Parameters a -> [a]
    forall a. (a -> a -> a) -> Parameters a -> a
    forall m a. Monoid m => (a -> m) -> Parameters a -> m
    forall b a. (b -> a -> b) -> b -> Parameters a -> b
    forall a b. (a -> b -> b) -> b -> Parameters a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Parameters m -> m
    fold :: forall m. Monoid m => Parameters m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Parameters a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Parameters a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Parameters a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Parameters a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Parameters a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Parameters a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Parameters a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Parameters a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Parameters a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Parameters a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Parameters a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Parameters a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Parameters a -> a
    foldr1 :: forall a. (a -> a -> a) -> Parameters a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Parameters a -> a
    foldl1 :: forall a. (a -> a -> a) -> Parameters a -> a
    $ctoList :: forall a. Parameters a -> [a]
    toList :: forall a. Parameters a -> [a]
    $cnull :: forall a. Parameters a -> Bool
    null :: forall a. Parameters a -> Bool
    $clength :: forall a. Parameters a -> Int
    length :: forall a. Parameters a -> Int
    $celem :: forall a. Eq a => a -> Parameters a -> Bool
    elem :: forall a. Eq a => a -> Parameters a -> Bool
    $cmaximum :: forall a. Ord a => Parameters a -> a
    maximum :: forall a. Ord a => Parameters a -> a
    $cminimum :: forall a. Ord a => Parameters a -> a
    minimum :: forall a. Ord a => Parameters a -> a
    $csum :: forall a. Num a => Parameters a -> a
    sum :: forall a. Num a => Parameters a -> a
    $cproduct :: forall a. Num a => Parameters a -> a
    product :: forall a. Num a => Parameters a -> a
    Foldable)

    data ParExpr t = ParExpr t (BList (Expr t)) t
                   | ParExprErr t
                     deriving (Int -> ParExpr t -> ShowS
    [ParExpr t] -> ShowS
    ParExpr t -> String
    (Int -> ParExpr t -> ShowS)
    -> (ParExpr t -> String)
    -> ([ParExpr t] -> ShowS)
    -> Show (ParExpr t)
    forall t. Show t => Int -> ParExpr t -> ShowS
    forall t. Show t => [ParExpr t] -> ShowS
    forall t. Show t => ParExpr t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> ParExpr t -> ShowS
    showsPrec :: Int -> ParExpr t -> ShowS
    $cshow :: forall t. Show t => ParExpr t -> String
    show :: ParExpr t -> String
    $cshowList :: forall t. Show t => [ParExpr t] -> ShowS
    showList :: [ParExpr t] -> ShowS
    Show, Typeable (ParExpr t)
    Typeable (ParExpr t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ParExpr t))
    -> (ParExpr t -> Constr)
    -> (ParExpr t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ParExpr t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ParExpr t)))
    -> ((forall b. Data b => b -> b) -> ParExpr t -> ParExpr t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ParExpr t -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ParExpr t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t))
    -> Data (ParExpr t)
    ParExpr t -> Constr
    ParExpr t -> DataType
    (forall b. Data b => b -> b) -> ParExpr t -> ParExpr t
    forall t. Data t => Typeable (ParExpr t)
    forall t. Data t => ParExpr t -> Constr
    forall t. Data t => ParExpr t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> ParExpr t -> ParExpr t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> ParExpr t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> ParExpr t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ParExpr t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ParExpr t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ParExpr t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ParExpr t -> u
    forall u. (forall d. Data d => d -> u) -> ParExpr t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ParExpr t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ParExpr t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ParExpr t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ParExpr t -> c (ParExpr t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ParExpr t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ParExpr t)
    $ctoConstr :: forall t. Data t => ParExpr t -> Constr
    toConstr :: ParExpr t -> Constr
    $cdataTypeOf :: forall t. Data t => ParExpr t -> DataType
    dataTypeOf :: ParExpr t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ParExpr t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ParExpr t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ParExpr t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ParExpr t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> ParExpr t -> ParExpr t
    gmapT :: (forall b. Data b => b -> b) -> ParExpr t -> ParExpr t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ParExpr t -> r
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> ParExpr t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ParExpr t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> ParExpr t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ParExpr t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ParExpr t -> m (ParExpr t)
    Data, Typeable, (forall m. Monoid m => ParExpr m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ParExpr a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ParExpr a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ParExpr a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ParExpr a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ParExpr a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ParExpr a -> b)
    -> (forall a. (a -> a -> a) -> ParExpr a -> a)
    -> (forall a. (a -> a -> a) -> ParExpr a -> a)
    -> (forall a. ParExpr a -> [a])
    -> (forall a. ParExpr a -> Bool)
    -> (forall a. ParExpr a -> Int)
    -> (forall a. Eq a => a -> ParExpr a -> Bool)
    -> (forall a. Ord a => ParExpr a -> a)
    -> (forall a. Ord a => ParExpr a -> a)
    -> (forall a. Num a => ParExpr a -> a)
    -> (forall a. Num a => ParExpr a -> a)
    -> Foldable ParExpr
    forall a. Eq a => a -> ParExpr a -> Bool
    forall a. Num a => ParExpr a -> a
    forall a. Ord a => ParExpr a -> a
    forall m. Monoid m => ParExpr m -> m
    forall a. ParExpr a -> Bool
    forall a. ParExpr a -> Int
    forall a. ParExpr a -> [a]
    forall a. (a -> a -> a) -> ParExpr a -> a
    forall m a. Monoid m => (a -> m) -> ParExpr a -> m
    forall b a. (b -> a -> b) -> b -> ParExpr a -> b
    forall a b. (a -> b -> b) -> b -> ParExpr a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ParExpr m -> m
    fold :: forall m. Monoid m => ParExpr m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ParExpr a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ParExpr a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ParExpr a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ParExpr a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ParExpr a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ParExpr a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ParExpr a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ParExpr a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ParExpr a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ParExpr a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ParExpr a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ParExpr a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ParExpr a -> a
    foldr1 :: forall a. (a -> a -> a) -> ParExpr a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ParExpr a -> a
    foldl1 :: forall a. (a -> a -> a) -> ParExpr a -> a
    $ctoList :: forall a. ParExpr a -> [a]
    toList :: forall a. ParExpr a -> [a]
    $cnull :: forall a. ParExpr a -> Bool
    null :: forall a. ParExpr a -> Bool
    $clength :: forall a. ParExpr a -> Int
    length :: forall a. ParExpr a -> Int
    $celem :: forall a. Eq a => a -> ParExpr a -> Bool
    elem :: forall a. Eq a => a -> ParExpr a -> Bool
    $cmaximum :: forall a. Ord a => ParExpr a -> a
    maximum :: forall a. Ord a => ParExpr a -> a
    $cminimum :: forall a. Ord a => ParExpr a -> a
    minimum :: forall a. Ord a => ParExpr a -> a
    $csum :: forall a. Num a => ParExpr a -> a
    sum :: forall a. Num a => ParExpr a -> a
    $cproduct :: forall a. Num a => ParExpr a -> a
    product :: forall a. Num a => ParExpr a -> a
    Foldable)

    data ForContent t = ForNormal t (Expr t) t (Expr t)
                      | ForIn t (Expr t)
                      | ForErr t
                        deriving (Int -> ForContent t -> ShowS
    [ForContent t] -> ShowS
    ForContent t -> String
    (Int -> ForContent t -> ShowS)
    -> (ForContent t -> String)
    -> ([ForContent t] -> ShowS)
    -> Show (ForContent t)
    forall t. Show t => Int -> ForContent t -> ShowS
    forall t. Show t => [ForContent t] -> ShowS
    forall t. Show t => ForContent t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> ForContent t -> ShowS
    showsPrec :: Int -> ForContent t -> ShowS
    $cshow :: forall t. Show t => ForContent t -> String
    show :: ForContent t -> String
    $cshowList :: forall t. Show t => [ForContent t] -> ShowS
    showList :: [ForContent t] -> ShowS
    Show, Typeable (ForContent t)
    Typeable (ForContent t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> ForContent t -> c (ForContent t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (ForContent t))
    -> (ForContent t -> Constr)
    -> (ForContent t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (ForContent t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (ForContent t)))
    -> ((forall b. Data b => b -> b) -> ForContent t -> ForContent t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> ForContent t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> ForContent t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> ForContent t -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> ForContent t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t))
    -> Data (ForContent t)
    ForContent t -> Constr
    ForContent t -> DataType
    (forall b. Data b => b -> b) -> ForContent t -> ForContent t
    forall t. Data t => Typeable (ForContent t)
    forall t. Data t => ForContent t -> Constr
    forall t. Data t => ForContent t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> ForContent t -> ForContent t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> ForContent t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> ForContent t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForContent t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForContent t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ForContent t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ForContent t -> c (ForContent t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ForContent t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ForContent t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> ForContent t -> u
    forall u. (forall d. Data d => d -> u) -> ForContent t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForContent t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForContent t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ForContent t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ForContent t -> c (ForContent t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ForContent t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ForContent t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ForContent t -> c (ForContent t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ForContent t -> c (ForContent t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ForContent t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ForContent t)
    $ctoConstr :: forall t. Data t => ForContent t -> Constr
    toConstr :: ForContent t -> Constr
    $cdataTypeOf :: forall t. Data t => ForContent t -> DataType
    dataTypeOf :: ForContent t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (ForContent t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ForContent t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ForContent t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ForContent t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> ForContent t -> ForContent t
    gmapT :: (forall b. Data b => b -> b) -> ForContent t -> ForContent t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForContent t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForContent t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForContent t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForContent t -> r
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> ForContent t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> ForContent t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> ForContent t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForContent t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForContent t -> m (ForContent t)
    Data, Typeable, (forall m. Monoid m => ForContent m -> m)
    -> (forall m a. Monoid m => (a -> m) -> ForContent a -> m)
    -> (forall m a. Monoid m => (a -> m) -> ForContent a -> m)
    -> (forall a b. (a -> b -> b) -> b -> ForContent a -> b)
    -> (forall a b. (a -> b -> b) -> b -> ForContent a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ForContent a -> b)
    -> (forall b a. (b -> a -> b) -> b -> ForContent a -> b)
    -> (forall a. (a -> a -> a) -> ForContent a -> a)
    -> (forall a. (a -> a -> a) -> ForContent a -> a)
    -> (forall a. ForContent a -> [a])
    -> (forall a. ForContent a -> Bool)
    -> (forall a. ForContent a -> Int)
    -> (forall a. Eq a => a -> ForContent a -> Bool)
    -> (forall a. Ord a => ForContent a -> a)
    -> (forall a. Ord a => ForContent a -> a)
    -> (forall a. Num a => ForContent a -> a)
    -> (forall a. Num a => ForContent a -> a)
    -> Foldable ForContent
    forall a. Eq a => a -> ForContent a -> Bool
    forall a. Num a => ForContent a -> a
    forall a. Ord a => ForContent a -> a
    forall m. Monoid m => ForContent m -> m
    forall a. ForContent a -> Bool
    forall a. ForContent a -> Int
    forall a. ForContent a -> [a]
    forall a. (a -> a -> a) -> ForContent a -> a
    forall m a. Monoid m => (a -> m) -> ForContent a -> m
    forall b a. (b -> a -> b) -> b -> ForContent a -> b
    forall a b. (a -> b -> b) -> b -> ForContent a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => ForContent m -> m
    fold :: forall m. Monoid m => ForContent m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> ForContent a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> ForContent a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> ForContent a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> ForContent a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> ForContent a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> ForContent a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> ForContent a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> ForContent a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> ForContent a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> ForContent a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> ForContent a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> ForContent a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> ForContent a -> a
    foldr1 :: forall a. (a -> a -> a) -> ForContent a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> ForContent a -> a
    foldl1 :: forall a. (a -> a -> a) -> ForContent a -> a
    $ctoList :: forall a. ForContent a -> [a]
    toList :: forall a. ForContent a -> [a]
    $cnull :: forall a. ForContent a -> Bool
    null :: forall a. ForContent a -> Bool
    $clength :: forall a. ForContent a -> Int
    length :: forall a. ForContent a -> Int
    $celem :: forall a. Eq a => a -> ForContent a -> Bool
    elem :: forall a. Eq a => a -> ForContent a -> Bool
    $cmaximum :: forall a. Ord a => ForContent a -> a
    maximum :: forall a. Ord a => ForContent a -> a
    $cminimum :: forall a. Ord a => ForContent a -> a
    minimum :: forall a. Ord a => ForContent a -> a
    $csum :: forall a. Num a => ForContent a -> a
    sum :: forall a. Num a => ForContent a -> a
    $cproduct :: forall a. Num a => ForContent a -> a
    product :: forall a. Num a => ForContent a -> a
    Foldable)

    data Block t = Block t (BList (Statement t)) t
                 | BlockOne (Statement t)
                 | BlockErr t
                   deriving (Int -> Block t -> ShowS
    [Block t] -> ShowS
    Block t -> String
    (Int -> Block t -> ShowS)
    -> (Block t -> String) -> ([Block t] -> ShowS) -> Show (Block t)
    forall t. Show t => Int -> Block t -> ShowS
    forall t. Show t => [Block t] -> ShowS
    forall t. Show t => Block t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> Block t -> ShowS
    showsPrec :: Int -> Block t -> ShowS
    $cshow :: forall t. Show t => Block t -> String
    show :: Block t -> String
    $cshowList :: forall t. Show t => [Block t] -> ShowS
    showList :: [Block t] -> ShowS
    Show, Typeable (Block t)
    Typeable (Block t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Block t -> c (Block t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Block t))
    -> (Block t -> Constr)
    -> (Block t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Block t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t)))
    -> ((forall b. Data b => b -> b) -> Block t -> Block t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Block t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Block t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Block t -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Block t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Block t -> m (Block t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Block t -> m (Block t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Block t -> m (Block t))
    -> Data (Block t)
    Block t -> Constr
    Block t -> DataType
    (forall b. Data b => b -> b) -> Block t -> Block t
    forall t. Data t => Typeable (Block t)
    forall t. Data t => Block t -> Constr
    forall t. Data t => Block t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Block t -> Block t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Block t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> Block t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Block t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Block t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Block t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block t -> c (Block t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Block t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Block t -> u
    forall u. (forall d. Data d => d -> u) -> Block t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Block t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Block t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Block t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block t -> c (Block t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Block t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block t -> c (Block t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Block t -> c (Block t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Block t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Block t)
    $ctoConstr :: forall t. Data t => Block t -> Constr
    toConstr :: Block t -> Constr
    $cdataTypeOf :: forall t. Data t => Block t -> DataType
    dataTypeOf :: Block t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Block t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Block t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Block t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Block t -> Block t
    gmapT :: (forall b. Data b => b -> b) -> Block t -> Block t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Block t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Block t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Block t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Block t -> r
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> Block t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Block t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Block t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Block t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Block t -> m (Block t)
    Data, Typeable, (forall m. Monoid m => Block m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Block a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Block a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Block a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Block a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Block a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Block a -> b)
    -> (forall a. (a -> a -> a) -> Block a -> a)
    -> (forall a. (a -> a -> a) -> Block a -> a)
    -> (forall a. Block a -> [a])
    -> (forall a. Block a -> Bool)
    -> (forall a. Block a -> Int)
    -> (forall a. Eq a => a -> Block a -> Bool)
    -> (forall a. Ord a => Block a -> a)
    -> (forall a. Ord a => Block a -> a)
    -> (forall a. Num a => Block a -> a)
    -> (forall a. Num a => Block a -> a)
    -> Foldable Block
    forall a. Eq a => a -> Block a -> Bool
    forall a. Num a => Block a -> a
    forall a. Ord a => Block a -> a
    forall m. Monoid m => Block m -> m
    forall a. Block a -> Bool
    forall a. Block a -> Int
    forall a. Block a -> [a]
    forall a. (a -> a -> a) -> Block a -> a
    forall m a. Monoid m => (a -> m) -> Block a -> m
    forall b a. (b -> a -> b) -> b -> Block a -> b
    forall a b. (a -> b -> b) -> b -> Block a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Block m -> m
    fold :: forall m. Monoid m => Block m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Block a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Block a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Block a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Block a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Block a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Block a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Block a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Block a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Block a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Block a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Block a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Block a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Block a -> a
    foldr1 :: forall a. (a -> a -> a) -> Block a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Block a -> a
    foldl1 :: forall a. (a -> a -> a) -> Block a -> a
    $ctoList :: forall a. Block a -> [a]
    toList :: forall a. Block a -> [a]
    $cnull :: forall a. Block a -> Bool
    null :: forall a. Block a -> Bool
    $clength :: forall a. Block a -> Int
    length :: forall a. Block a -> Int
    $celem :: forall a. Eq a => a -> Block a -> Bool
    elem :: forall a. Eq a => a -> Block a -> Bool
    $cmaximum :: forall a. Ord a => Block a -> a
    maximum :: forall a. Ord a => Block a -> a
    $cminimum :: forall a. Ord a => Block a -> a
    minimum :: forall a. Ord a => Block a -> a
    $csum :: forall a. Num a => Block a -> a
    sum :: forall a. Num a => Block a -> a
    $cproduct :: forall a. Num a => Block a -> a
    product :: forall a. Num a => Block a -> a
    Foldable)

    -- | Represents either a variable name or a variable name assigned to an
    --   expression.  @AssBeg@ is a variable name /maybe/ followed by an assignment.
    --   @AssRst@ is an equals sign and an expression.  @(AssBeg 'x' (Just (AssRst
    --   '=' '5')))@ means @x = 5@.
    data VarDecAss t = AssBeg t (Maybe (VarDecAss t))
                     | AssRst t (Expr t)
                     | AssErr t
                       deriving (Int -> VarDecAss t -> ShowS
    [VarDecAss t] -> ShowS
    VarDecAss t -> String
    (Int -> VarDecAss t -> ShowS)
    -> (VarDecAss t -> String)
    -> ([VarDecAss t] -> ShowS)
    -> Show (VarDecAss t)
    forall t. Show t => Int -> VarDecAss t -> ShowS
    forall t. Show t => [VarDecAss t] -> ShowS
    forall t. Show t => VarDecAss t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> VarDecAss t -> ShowS
    showsPrec :: Int -> VarDecAss t -> ShowS
    $cshow :: forall t. Show t => VarDecAss t -> String
    show :: VarDecAss t -> String
    $cshowList :: forall t. Show t => [VarDecAss t] -> ShowS
    showList :: [VarDecAss t] -> ShowS
    Show, Typeable (VarDecAss t)
    Typeable (VarDecAss t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (VarDecAss t))
    -> (VarDecAss t -> Constr)
    -> (VarDecAss t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (VarDecAss t)))
    -> ((forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> VarDecAss t -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t))
    -> Data (VarDecAss t)
    VarDecAss t -> Constr
    VarDecAss t -> DataType
    (forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
    forall t. Data t => Typeable (VarDecAss t)
    forall t. Data t => VarDecAss t -> Constr
    forall t. Data t => VarDecAss t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> VarDecAss t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VarDecAss t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
    forall u. (forall d. Data d => d -> u) -> VarDecAss t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VarDecAss t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> VarDecAss t -> c (VarDecAss t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (VarDecAss t)
    $ctoConstr :: forall t. Data t => VarDecAss t -> Constr
    toConstr :: VarDecAss t -> Constr
    $cdataTypeOf :: forall t. Data t => VarDecAss t -> DataType
    dataTypeOf :: VarDecAss t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (VarDecAss t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VarDecAss t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (VarDecAss t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
    gmapT :: (forall b. Data b => b -> b) -> VarDecAss t -> VarDecAss t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> VarDecAss t -> r
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> VarDecAss t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> VarDecAss t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> VarDecAss t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> VarDecAss t -> m (VarDecAss t)
    Data, Typeable, (forall m. Monoid m => VarDecAss m -> m)
    -> (forall m a. Monoid m => (a -> m) -> VarDecAss a -> m)
    -> (forall m a. Monoid m => (a -> m) -> VarDecAss a -> m)
    -> (forall a b. (a -> b -> b) -> b -> VarDecAss a -> b)
    -> (forall a b. (a -> b -> b) -> b -> VarDecAss a -> b)
    -> (forall b a. (b -> a -> b) -> b -> VarDecAss a -> b)
    -> (forall b a. (b -> a -> b) -> b -> VarDecAss a -> b)
    -> (forall a. (a -> a -> a) -> VarDecAss a -> a)
    -> (forall a. (a -> a -> a) -> VarDecAss a -> a)
    -> (forall a. VarDecAss a -> [a])
    -> (forall a. VarDecAss a -> Bool)
    -> (forall a. VarDecAss a -> Int)
    -> (forall a. Eq a => a -> VarDecAss a -> Bool)
    -> (forall a. Ord a => VarDecAss a -> a)
    -> (forall a. Ord a => VarDecAss a -> a)
    -> (forall a. Num a => VarDecAss a -> a)
    -> (forall a. Num a => VarDecAss a -> a)
    -> Foldable VarDecAss
    forall a. Eq a => a -> VarDecAss a -> Bool
    forall a. Num a => VarDecAss a -> a
    forall a. Ord a => VarDecAss a -> a
    forall m. Monoid m => VarDecAss m -> m
    forall a. VarDecAss a -> Bool
    forall a. VarDecAss a -> Int
    forall a. VarDecAss a -> [a]
    forall a. (a -> a -> a) -> VarDecAss a -> a
    forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
    forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
    forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => VarDecAss m -> m
    fold :: forall m. Monoid m => VarDecAss m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> VarDecAss a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> VarDecAss a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> VarDecAss a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> VarDecAss a -> a
    foldr1 :: forall a. (a -> a -> a) -> VarDecAss a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> VarDecAss a -> a
    foldl1 :: forall a. (a -> a -> a) -> VarDecAss a -> a
    $ctoList :: forall a. VarDecAss a -> [a]
    toList :: forall a. VarDecAss a -> [a]
    $cnull :: forall a. VarDecAss a -> Bool
    null :: forall a. VarDecAss a -> Bool
    $clength :: forall a. VarDecAss a -> Int
    length :: forall a. VarDecAss a -> Int
    $celem :: forall a. Eq a => a -> VarDecAss a -> Bool
    elem :: forall a. Eq a => a -> VarDecAss a -> Bool
    $cmaximum :: forall a. Ord a => VarDecAss a -> a
    maximum :: forall a. Ord a => VarDecAss a -> a
    $cminimum :: forall a. Ord a => VarDecAss a -> a
    minimum :: forall a. Ord a => VarDecAss a -> a
    $csum :: forall a. Num a => VarDecAss a -> a
    sum :: forall a. Num a => VarDecAss a -> a
    $cproduct :: forall a. Num a => VarDecAss a -> a
    product :: forall a. Num a => VarDecAss a -> a
    Foldable)

    data Expr t = ExprObj t (BList (KeyValue t)) t
                | ExprPrefix t (Expr t)
                | ExprNew t (Expr t)
                | ExprSimple t (Maybe (Expr t))
                | ExprParen t (Expr t) t (Maybe (Expr t))
                | ExprAnonFun t (Parameters t) (Block t)
                | ExprTypeOf t (Expr t)
                | ExprFunCall t (ParExpr t) (Maybe (Expr t))
                | OpExpr t (Expr t)
                | ExprCond t (Expr t) t (Expr t)
                | ExprArr t (Maybe (Array t)) t (Maybe (Expr t))
                | PostExpr t
                | ExprErr t
                  deriving (Int -> Expr t -> ShowS
    [Expr t] -> ShowS
    Expr t -> String
    (Int -> Expr t -> ShowS)
    -> (Expr t -> String) -> ([Expr t] -> ShowS) -> Show (Expr t)
    forall t. Show t => Int -> Expr t -> ShowS
    forall t. Show t => [Expr t] -> ShowS
    forall t. Show t => Expr t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> Expr t -> ShowS
    showsPrec :: Int -> Expr t -> ShowS
    $cshow :: forall t. Show t => Expr t -> String
    show :: Expr t -> String
    $cshowList :: forall t. Show t => [Expr t] -> ShowS
    showList :: [Expr t] -> ShowS
    Show, Typeable (Expr t)
    Typeable (Expr t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Expr t -> c (Expr t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Expr t))
    -> (Expr t -> Constr)
    -> (Expr t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Expr t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t)))
    -> ((forall b. Data b => b -> b) -> Expr t -> Expr t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Expr t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Expr t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Expr t -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Expr t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Expr t -> m (Expr t))
    -> Data (Expr t)
    Expr t -> Constr
    Expr t -> DataType
    (forall b. Data b => b -> b) -> Expr t -> Expr t
    forall t. Data t => Typeable (Expr t)
    forall t. Data t => Expr t -> Constr
    forall t. Data t => Expr t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Expr t -> Expr t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Expr t -> u
    forall t u. Data t => (forall d. Data d => d -> u) -> Expr t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expr t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr t -> c (Expr t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expr t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Expr t -> u
    forall u. (forall d. Data d => d -> u) -> Expr t -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expr t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr t -> c (Expr t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expr t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr t -> c (Expr t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr t -> c (Expr t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expr t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Expr t)
    $ctoConstr :: forall t. Data t => Expr t -> Constr
    toConstr :: Expr t -> Constr
    $cdataTypeOf :: forall t. Data t => Expr t -> DataType
    dataTypeOf :: Expr t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expr t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Expr t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Expr t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Expr t -> Expr t
    gmapT :: (forall b. Data b => b -> b) -> Expr t -> Expr t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr t -> r
    $cgmapQ :: forall t u. Data t => (forall d. Data d => d -> u) -> Expr t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Expr t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Expr t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr t -> m (Expr t)
    Data, Typeable, (forall m. Monoid m => Expr m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Expr a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Expr a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Expr a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Expr a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Expr a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Expr a -> b)
    -> (forall a. (a -> a -> a) -> Expr a -> a)
    -> (forall a. (a -> a -> a) -> Expr a -> a)
    -> (forall a. Expr a -> [a])
    -> (forall a. Expr a -> Bool)
    -> (forall a. Expr a -> Int)
    -> (forall a. Eq a => a -> Expr a -> Bool)
    -> (forall a. Ord a => Expr a -> a)
    -> (forall a. Ord a => Expr a -> a)
    -> (forall a. Num a => Expr a -> a)
    -> (forall a. Num a => Expr a -> a)
    -> Foldable Expr
    forall a. Eq a => a -> Expr a -> Bool
    forall a. Num a => Expr a -> a
    forall a. Ord a => Expr a -> a
    forall m. Monoid m => Expr m -> m
    forall a. Expr a -> Bool
    forall a. Expr a -> Int
    forall a. Expr a -> [a]
    forall a. (a -> a -> a) -> Expr a -> a
    forall m a. Monoid m => (a -> m) -> Expr a -> m
    forall b a. (b -> a -> b) -> b -> Expr a -> b
    forall a b. (a -> b -> b) -> b -> Expr a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Expr m -> m
    fold :: forall m. Monoid m => Expr m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Expr a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Expr a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Expr a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Expr a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Expr a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Expr a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Expr a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Expr a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Expr a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Expr a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Expr a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Expr a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Expr a -> a
    foldr1 :: forall a. (a -> a -> a) -> Expr a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Expr a -> a
    foldl1 :: forall a. (a -> a -> a) -> Expr a -> a
    $ctoList :: forall a. Expr a -> [a]
    toList :: forall a. Expr a -> [a]
    $cnull :: forall a. Expr a -> Bool
    null :: forall a. Expr a -> Bool
    $clength :: forall a. Expr a -> Int
    length :: forall a. Expr a -> Int
    $celem :: forall a. Eq a => a -> Expr a -> Bool
    elem :: forall a. Eq a => a -> Expr a -> Bool
    $cmaximum :: forall a. Ord a => Expr a -> a
    maximum :: forall a. Ord a => Expr a -> a
    $cminimum :: forall a. Ord a => Expr a -> a
    minimum :: forall a. Ord a => Expr a -> a
    $csum :: forall a. Num a => Expr a -> a
    sum :: forall a. Num a => Expr a -> a
    $cproduct :: forall a. Num a => Expr a -> a
    product :: forall a. Num a => Expr a -> a
    Foldable)

    data Array t = ArrCont (Expr t) (Maybe (Array t))
                 | ArrRest t (Array t) (Maybe (Array t))
                 | ArrErr t
                   deriving (Int -> Array t -> ShowS
    [Array t] -> ShowS
    Array t -> String
    (Int -> Array t -> ShowS)
    -> (Array t -> String) -> ([Array t] -> ShowS) -> Show (Array t)
    forall t. Show t => Int -> Array t -> ShowS
    forall t. Show t => [Array t] -> ShowS
    forall t. Show t => Array t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> Array t -> ShowS
    showsPrec :: Int -> Array t -> ShowS
    $cshow :: forall t. Show t => Array t -> String
    show :: Array t -> String
    $cshowList :: forall t. Show t => [Array t] -> ShowS
    showList :: [Array t] -> ShowS
    Show, Typeable (Array t)
    Typeable (Array t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Array t -> c (Array t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Array t))
    -> (Array t -> Constr)
    -> (Array t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Array t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t)))
    -> ((forall b. Data b => b -> b) -> Array t -> Array t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Array t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Array t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Array t -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Array t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Array t -> m (Array t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Array t -> m (Array t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Array t -> m (Array t))
    -> Data (Array t)
    Array t -> Constr
    Array t -> DataType
    (forall b. Data b => b -> b) -> Array t -> Array t
    forall t. Data t => Typeable (Array t)
    forall t. Data t => Array t -> Constr
    forall t. Data t => Array t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Array t -> Array t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Array t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> Array t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Array t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Array t -> c (Array t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Array t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Array t -> u
    forall u. (forall d. Data d => d -> u) -> Array t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Array t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Array t -> c (Array t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Array t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Array t -> c (Array t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Array t -> c (Array t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Array t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Array t)
    $ctoConstr :: forall t. Data t => Array t -> Constr
    toConstr :: Array t -> Constr
    $cdataTypeOf :: forall t. Data t => Array t -> DataType
    dataTypeOf :: Array t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Array t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Array t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> Array t -> Array t
    gmapT :: (forall b. Data b => b -> b) -> Array t -> Array t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Array t -> r
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> Array t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Array t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> Array t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Array t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Array t -> m (Array t)
    Data, Typeable, (forall m. Monoid m => Array m -> m)
    -> (forall m a. Monoid m => (a -> m) -> Array a -> m)
    -> (forall m a. Monoid m => (a -> m) -> Array a -> m)
    -> (forall a b. (a -> b -> b) -> b -> Array a -> b)
    -> (forall a b. (a -> b -> b) -> b -> Array a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Array a -> b)
    -> (forall b a. (b -> a -> b) -> b -> Array a -> b)
    -> (forall a. (a -> a -> a) -> Array a -> a)
    -> (forall a. (a -> a -> a) -> Array a -> a)
    -> (forall a. Array a -> [a])
    -> (forall a. Array a -> Bool)
    -> (forall a. Array a -> Int)
    -> (forall a. Eq a => a -> Array a -> Bool)
    -> (forall a. Ord a => Array a -> a)
    -> (forall a. Ord a => Array a -> a)
    -> (forall a. Num a => Array a -> a)
    -> (forall a. Num a => Array a -> a)
    -> Foldable Array
    forall a. Eq a => a -> Array a -> Bool
    forall a. Num a => Array a -> a
    forall a. Ord a => Array a -> a
    forall m. Monoid m => Array m -> m
    forall a. Array a -> Bool
    forall a. Array a -> Int
    forall a. Array a -> [a]
    forall a. (a -> a -> a) -> Array a -> a
    forall m a. Monoid m => (a -> m) -> Array a -> m
    forall b a. (b -> a -> b) -> b -> Array a -> b
    forall a b. (a -> b -> b) -> b -> Array a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => Array m -> m
    fold :: forall m. Monoid m => Array m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> Array a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> Array a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> Array a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> Array a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> Array a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> Array a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> Array a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> Array a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> Array a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> Array a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> Array a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> Array a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> Array a -> a
    foldr1 :: forall a. (a -> a -> a) -> Array a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> Array a -> a
    foldl1 :: forall a. (a -> a -> a) -> Array a -> a
    $ctoList :: forall a. Array a -> [a]
    toList :: forall a. Array a -> [a]
    $cnull :: forall a. Array a -> Bool
    null :: forall a. Array a -> Bool
    $clength :: forall a. Array a -> Int
    length :: forall a. Array a -> Int
    $celem :: forall a. Eq a => a -> Array a -> Bool
    elem :: forall a. Eq a => a -> Array a -> Bool
    $cmaximum :: forall a. Ord a => Array a -> a
    maximum :: forall a. Ord a => Array a -> a
    $cminimum :: forall a. Ord a => Array a -> a
    minimum :: forall a. Ord a => Array a -> a
    $csum :: forall a. Num a => Array a -> a
    sum :: forall a. Num a => Array a -> a
    $cproduct :: forall a. Num a => Array a -> a
    product :: forall a. Num a => Array a -> a
    Foldable)

    data KeyValue t = KeyValue t t (Expr t)
                    | KeyValueErr t
                      deriving (Int -> KeyValue t -> ShowS
    [KeyValue t] -> ShowS
    KeyValue t -> String
    (Int -> KeyValue t -> ShowS)
    -> (KeyValue t -> String)
    -> ([KeyValue t] -> ShowS)
    -> Show (KeyValue t)
    forall t. Show t => Int -> KeyValue t -> ShowS
    forall t. Show t => [KeyValue t] -> ShowS
    forall t. Show t => KeyValue t -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall t. Show t => Int -> KeyValue t -> ShowS
    showsPrec :: Int -> KeyValue t -> ShowS
    $cshow :: forall t. Show t => KeyValue t -> String
    show :: KeyValue t -> String
    $cshowList :: forall t. Show t => [KeyValue t] -> ShowS
    showList :: [KeyValue t] -> ShowS
    Show, Typeable (KeyValue t)
    Typeable (KeyValue t) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (KeyValue t))
    -> (KeyValue t -> Constr)
    -> (KeyValue t -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (KeyValue t)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (KeyValue t)))
    -> ((forall b. Data b => b -> b) -> KeyValue t -> KeyValue t)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r)
    -> (forall u. (forall d. Data d => d -> u) -> KeyValue t -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> KeyValue t -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t))
    -> Data (KeyValue t)
    KeyValue t -> Constr
    KeyValue t -> DataType
    (forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
    forall t. Data t => Typeable (KeyValue t)
    forall t. Data t => KeyValue t -> Constr
    forall t. Data t => KeyValue t -> DataType
    forall t.
    Data t =>
    (forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
    forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
    forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> KeyValue t -> [u]
    forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
    forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
    forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (KeyValue t)
    forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
    forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
    forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (KeyValue t))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
    forall u. (forall d. Data d => d -> u) -> KeyValue t -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (KeyValue t)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (KeyValue t))
    $cgfoldl :: forall t (c :: * -> *).
    Data t =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> KeyValue t -> c (KeyValue t)
    $cgunfold :: forall t (c :: * -> *).
    Data t =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (KeyValue t)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (KeyValue t)
    $ctoConstr :: forall t. Data t => KeyValue t -> Constr
    toConstr :: KeyValue t -> Constr
    $cdataTypeOf :: forall t. Data t => KeyValue t -> DataType
    dataTypeOf :: KeyValue t -> DataType
    $cdataCast1 :: forall t (t :: * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (KeyValue t))
    $cdataCast2 :: forall t (t :: * -> * -> *) (c :: * -> *).
    (Data t, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (KeyValue t))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (KeyValue t))
    $cgmapT :: forall t.
    Data t =>
    (forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
    gmapT :: (forall b. Data b => b -> b) -> KeyValue t -> KeyValue t
    $cgmapQl :: forall t r r'.
    Data t =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
    $cgmapQr :: forall t r r'.
    Data t =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyValue t -> r
    $cgmapQ :: forall t u.
    Data t =>
    (forall d. Data d => d -> u) -> KeyValue t -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> KeyValue t -> [u]
    $cgmapQi :: forall t u.
    Data t =>
    Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyValue t -> u
    $cgmapM :: forall t (m :: * -> *).
    (Data t, Monad m) =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    $cgmapMp :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    $cgmapMo :: forall t (m :: * -> *).
    (Data t, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyValue t -> m (KeyValue t)
    Data, Typeable, (forall m. Monoid m => KeyValue m -> m)
    -> (forall m a. Monoid m => (a -> m) -> KeyValue a -> m)
    -> (forall m a. Monoid m => (a -> m) -> KeyValue a -> m)
    -> (forall a b. (a -> b -> b) -> b -> KeyValue a -> b)
    -> (forall a b. (a -> b -> b) -> b -> KeyValue a -> b)
    -> (forall b a. (b -> a -> b) -> b -> KeyValue a -> b)
    -> (forall b a. (b -> a -> b) -> b -> KeyValue a -> b)
    -> (forall a. (a -> a -> a) -> KeyValue a -> a)
    -> (forall a. (a -> a -> a) -> KeyValue a -> a)
    -> (forall a. KeyValue a -> [a])
    -> (forall a. KeyValue a -> Bool)
    -> (forall a. KeyValue a -> Int)
    -> (forall a. Eq a => a -> KeyValue a -> Bool)
    -> (forall a. Ord a => KeyValue a -> a)
    -> (forall a. Ord a => KeyValue a -> a)
    -> (forall a. Num a => KeyValue a -> a)
    -> (forall a. Num a => KeyValue a -> a)
    -> Foldable KeyValue
    forall a. Eq a => a -> KeyValue a -> Bool
    forall a. Num a => KeyValue a -> a
    forall a. Ord a => KeyValue a -> a
    forall m. Monoid m => KeyValue m -> m
    forall a. KeyValue a -> Bool
    forall a. KeyValue a -> Int
    forall a. KeyValue a -> [a]
    forall a. (a -> a -> a) -> KeyValue a -> a
    forall m a. Monoid m => (a -> m) -> KeyValue a -> m
    forall b a. (b -> a -> b) -> b -> KeyValue a -> b
    forall a b. (a -> b -> b) -> b -> KeyValue a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall m. Monoid m => KeyValue m -> m
    fold :: forall m. Monoid m => KeyValue m -> m
    $cfoldMap :: forall m a. Monoid m => (a -> m) -> KeyValue a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> KeyValue a -> m
    $cfoldMap' :: forall m a. Monoid m => (a -> m) -> KeyValue a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> KeyValue a -> m
    $cfoldr :: forall a b. (a -> b -> b) -> b -> KeyValue a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> KeyValue a -> b
    $cfoldr' :: forall a b. (a -> b -> b) -> b -> KeyValue a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> KeyValue a -> b
    $cfoldl :: forall b a. (b -> a -> b) -> b -> KeyValue a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> KeyValue a -> b
    $cfoldl' :: forall b a. (b -> a -> b) -> b -> KeyValue a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> KeyValue a -> b
    $cfoldr1 :: forall a. (a -> a -> a) -> KeyValue a -> a
    foldr1 :: forall a. (a -> a -> a) -> KeyValue a -> a
    $cfoldl1 :: forall a. (a -> a -> a) -> KeyValue a -> a
    foldl1 :: forall a. (a -> a -> a) -> KeyValue a -> a
    $ctoList :: forall a. KeyValue a -> [a]
    toList :: forall a. KeyValue a -> [a]
    $cnull :: forall a. KeyValue a -> Bool
    null :: forall a. KeyValue a -> Bool
    $clength :: forall a. KeyValue a -> Int
    length :: forall a. KeyValue a -> Int
    $celem :: forall a. Eq a => a -> KeyValue a -> Bool
    elem :: forall a. Eq a => a -> KeyValue a -> Bool
    $cmaximum :: forall a. Ord a => KeyValue a -> a
    maximum :: forall a. Ord a => KeyValue a -> a
    $cminimum :: forall a. Ord a => KeyValue a -> a
    minimum :: forall a. Ord a => KeyValue a -> a
    $csum :: forall a. Num a => KeyValue a -> a
    sum :: forall a. Num a => KeyValue a -> a
    $cproduct :: forall a. Num a => KeyValue a -> a
    product :: forall a. Num a => KeyValue a -> a
    Foldable)

    instance IsTree Statement where
        subtrees :: forall t. Statement t -> [Statement t]
    subtrees (FunDecl t
    _ t
    _ Parameters t
    _ Block t
    x) = Block t -> [Statement t]
    forall t. Block t -> [Statement t]
    fromBlock Block t
    x
        subtrees (While t
    _ ParExpr t
    _ Block t
    x) = Block t -> [Statement t]
    forall t. Block t -> [Statement t]
    fromBlock Block t
    x
        subtrees (DoWhile t
    _ Block t
    x t
    _ ParExpr t
    _ Semicolon t
    _) = Block t -> [Statement t]
    forall t. Block t -> [Statement t]
    fromBlock Block t
    x
        subtrees (For t
    _ t
    _ Expr t
    _ ForContent t
    _ t
    _ Block t
    x) = Block t -> [Statement t]
    forall t. Block t -> [Statement t]
    fromBlock Block t
    x
        subtrees (If t
    _ ParExpr t
    _ Block t
    x Maybe (Statement t)
    mb) = Block t -> [Statement t]
    forall t. Block t -> [Statement t]
    fromBlock Block t
    x [Statement t] -> [Statement t] -> [Statement t]
    forall a. Semigroup a => a -> a -> a
    <> [Statement t]
    -> (Statement t -> [Statement t])
    -> Maybe (Statement t)
    -> [Statement t]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe [] Statement t -> [Statement t]
    forall t. Statement t -> [Statement t]
    forall (tree :: * -> *) t. IsTree tree => tree t -> [tree t]
    subtrees Maybe (Statement t)
    mb
        subtrees (Else t
    _ Block t
    x) = Block t -> [Statement t]
    forall t. Block t -> [Statement t]
    fromBlock Block t
    x
        subtrees (With t
    _ ParExpr t
    _ Block t
    x) = Block t -> [Statement t]
    forall t. Block t -> [Statement t]
    fromBlock Block t
    x
        subtrees Statement t
    _ = []
        uniplate :: forall t.
    Statement t -> ([Statement t], [Statement t] -> Statement t)
    uniplate = String
    -> Statement t -> ([Statement t], [Statement t] -> Statement t)
    forall a. HasCallStack => String -> a
    Prelude.error String
    "uniplate not implemented in IsTree (Yi.Syntax.JavaScript.Statement)"
        emptyNode :: forall t. Statement t
    emptyNode = String -> Statement t
    forall a. HasCallStack => String -> a
    Prelude.error String
    "emptyNode not implemented in IsTree (Yi.Syntax.JavaScript.Statement)"

    instance Failable ForContent where
        stupid :: forall t. t -> ForContent t
    stupid = t -> ForContent t
    forall t. t -> ForContent t
    ForErr
        hasFailed :: forall a. ForContent a -> Bool
    hasFailed ForContent t
    t = case ForContent t
    t of
                        ForErr t
    _ -> Bool
    True
                        ForContent t
    _        -> Bool
    False

    instance Failable Block where
        stupid :: forall t. t -> Block t
    stupid = t -> Block t
    forall t. t -> Block t
    BlockErr
        hasFailed :: forall a. Block a -> Bool
    hasFailed Block t
    t = case Block t
    t of
                        BlockErr t
    _ -> Bool
    True
                        Block t
    _          -> Bool
    False

    instance Failable VarDecAss where
        stupid :: forall t. t -> VarDecAss t
    stupid = t -> VarDecAss t
    forall t. t -> VarDecAss t
    AssErr
        hasFailed :: forall a. VarDecAss a -> Bool
    hasFailed VarDecAss t
    t = case VarDecAss t
    t of
                        AssErr t
    _ -> Bool
    True
                        VarDecAss t
    _        -> Bool
    False

    instance Failable Parameters where
        stupid :: forall t. t -> Parameters t
    stupid = t -> Parameters t
    forall t. t -> Parameters t
    ParErr
        hasFailed :: forall a. Parameters a -> Bool
    hasFailed Parameters t
    t = case Parameters t
    t of
                        ParErr t
    _ -> Bool
    True
                        Parameters t
    _        -> Bool
    False

    instance Failable ParExpr where
        stupid :: forall t. t -> ParExpr t
    stupid = t -> ParExpr t
    forall t. t -> ParExpr t
    ParExprErr
        hasFailed :: forall a. ParExpr a -> Bool
    hasFailed ParExpr t
    t = case ParExpr t
    t of
                        ParExprErr t
    _ -> Bool
    True
                        ParExpr t
    _            -> Bool
    False

    instance Failable Expr where
        stupid :: forall t. t -> Expr t
    stupid = t -> Expr t
    forall t. t -> Expr t
    ExprErr
        hasFailed :: forall a. Expr a -> Bool
    hasFailed Expr t
    t = case Expr t
    t of
                        ExprErr t
    _ -> Bool
    True
                        Expr t
    _         -> Bool
    False

    instance Failable KeyValue where
        stupid :: forall t. t -> KeyValue t
    stupid = t -> KeyValue t
    forall t. t -> KeyValue t
    KeyValueErr
        hasFailed :: forall a. KeyValue a -> Bool
    hasFailed KeyValue t
    t = case KeyValue t
    t of
                        KeyValueErr t
    _ -> Bool
    True
                        KeyValue t
    _             -> Bool
    False

    -- | TODO: This code is *screaming* for some generic programming.
    --
    --   TODO: Somehow fix Failable and failStroker to be more "generic".  This will
    --   make these instances much nicer and we won't have to make ad-hoc stuff like
    --   this.
    instance Strokable (Statement TT) where
        toStrokes :: Statement TT -> Endo [Stroke]
    toStrokes (FunDecl TT
    f TT
    n Parameters TT
    ps Block TT
    blk) =
            let s :: TT -> Endo [Stroke]
    s = if Block TT -> Bool
    forall a. Block a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Block TT
    blk then TT -> Endo [Stroke]
    error else [TT] -> TT -> Endo [Stroke]
    failStroker [TT
    n] in
            TT -> Endo [Stroke]
    s TT
    f Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    n Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Parameters TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Parameters TT
    ps Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Block TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Block TT
    blk
        toStrokes (VarDecl TT
    v BList (VarDecAss TT)
    vs Semicolon TT
    sc) =
            let s :: TT -> Endo [Stroke]
    s = if (VarDecAss TT -> Bool) -> BList (VarDecAss TT) -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any VarDecAss TT -> Bool
    forall a. VarDecAss a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed BList (VarDecAss TT)
    vs then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s TT
    v Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> (VarDecAss TT -> Endo [Stroke])
    -> BList (VarDecAss TT) -> Endo [Stroke]
    forall m a. Monoid m => (a -> m) -> [a] -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap VarDecAss TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes BList (VarDecAss TT)
    vs Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty TT -> Endo [Stroke]
    s Semicolon TT
    sc
        toStrokes (Return TT
    t Maybe (Expr TT)
    exp Semicolon TT
    sc) = TT -> Endo [Stroke]
    normal TT
    t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (Expr TT)
    exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty TT -> Endo [Stroke]
    normal Semicolon TT
    sc
        toStrokes (While TT
    w ParExpr TT
    exp Block TT
    blk) =
            let s :: TT -> Endo [Stroke]
    s = if Block TT -> Bool
    forall a. Block a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Block TT
    blk Bool -> Bool -> Bool
    || Block TT -> Bool
    forall a. Block a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Block TT
    blk then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s TT
    w Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> ParExpr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes ParExpr TT
    exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Block TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Block TT
    blk
        toStrokes (DoWhile TT
    d Block TT
    blk TT
    w ParExpr TT
    exp Semicolon TT
    sc) =
            let s1 :: TT -> Endo [Stroke]
    s1 = if Block TT -> Bool
    forall a. Block a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Block TT
    blk then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal
                s2 :: TT -> Endo [Stroke]
    s2 = if ParExpr TT -> Bool
    forall a. ParExpr a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed ParExpr TT
    exp then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s1 TT
    d Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Block TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Block TT
    blk Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s2 TT
    w Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> ParExpr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes ParExpr TT
    exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty TT -> Endo [Stroke]
    normal Semicolon TT
    sc
        toStrokes (For TT
    f TT
    l Expr TT
    x ForContent TT
    c TT
    r Block TT
    blk) =
            let s :: TT -> Endo [Stroke]
    s = if Block TT -> Bool
    forall a. Block a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Block TT
    blk Bool -> Bool -> Bool
    || ForContent TT -> Bool
    forall a. ForContent a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed ForContent TT
    c Bool -> Bool -> Bool
    || Expr TT -> Bool
    forall a. Expr a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Expr TT
    x
                      then TT -> Endo [Stroke]
    error
                      else [TT] -> TT -> Endo [Stroke]
    failStroker [TT
    f, TT
    l, TT
    r] in
            TT -> Endo [Stroke]
    s TT
    f Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> ForContent TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes ForContent TT
    c Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    r Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Block TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Block TT
    blk
        toStrokes (If TT
    i ParExpr TT
    x Block TT
    blk Maybe (Statement TT)
    e) =
            let s :: TT -> Endo [Stroke]
    s = if Block TT -> Bool
    forall a. Block a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Block TT
    blk then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s TT
    i Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> ParExpr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes ParExpr TT
    x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Block TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Block TT
    blk Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (Statement TT -> Endo [Stroke])
    -> Maybe (Statement TT)
    -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty Statement TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (Statement TT)
    e
        toStrokes (Else TT
    e Block TT
    blk) = TT -> Endo [Stroke]
    normal TT
    e Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Block TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Block TT
    blk
        toStrokes (With TT
    w ParExpr TT
    x Block TT
    blk) = TT -> Endo [Stroke]
    normal TT
    w Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> ParExpr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes ParExpr TT
    x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Block TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Block TT
    blk
        toStrokes (Expr Expr TT
    exp Semicolon TT
    sc) = Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (TT -> Endo [Stroke]) -> Semicolon TT -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty TT -> Endo [Stroke]
    normal Semicolon TT
    sc
        toStrokes (Comm TT
    t) = TT -> Endo [Stroke]
    normal TT
    t

    instance Strokable (ForContent TT) where
        toStrokes :: ForContent TT -> Endo [Stroke]
    toStrokes (ForNormal TT
    s1 Expr TT
    x2 TT
    s2 Expr TT
    x3) =
            let s :: TT -> Endo [Stroke]
    s = if (Expr TT -> Bool) -> [Expr TT] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any Expr TT -> Bool
    forall a. Expr a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed [Expr TT
    x2, Expr TT
    x3] then TT -> Endo [Stroke]
    error else [TT] -> TT -> Endo [Stroke]
    failStroker [TT
    s2] in
            TT -> Endo [Stroke]
    s TT
    s1 Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    x2 Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    s2 Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    x3
        toStrokes (ForIn TT
    i Expr TT
    x) =
            let s :: TT -> Endo [Stroke]
    s = if Expr TT -> Bool
    forall a. Expr a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Expr TT
    x then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s TT
    i Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    x
        toStrokes (ForErr TT
    t) = TT -> Endo [Stroke]
    error TT
    t

    instance Strokable (Block TT) where
        toStrokes :: Block TT -> Endo [Stroke]
    toStrokes (BlockOne Statement TT
    stmt) = Statement TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Statement TT
    stmt
        toStrokes (Block TT
    l Tree TT
    stmts TT
    r) =
            let s :: TT -> Endo [Stroke]
    s = [TT] -> TT -> Endo [Stroke]
    failStroker [TT
    l, TT
    r] in
            TT -> Endo [Stroke]
    s TT
    l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> (Statement TT -> Endo [Stroke]) -> Tree TT -> Endo [Stroke]
    forall m a. Monoid m => (a -> m) -> [a] -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap Statement TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Tree TT
    stmts Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    r
        toStrokes (BlockErr TT
    t) = TT -> Endo [Stroke]
    error TT
    t

    instance Strokable (VarDecAss TT) where
        toStrokes :: VarDecAss TT -> Endo [Stroke]
    toStrokes (AssBeg TT
    t Maybe (VarDecAss TT)
    x) = TT -> Endo [Stroke]
    normal TT
    t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (VarDecAss TT -> Endo [Stroke])
    -> Maybe (VarDecAss TT)
    -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty VarDecAss TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (VarDecAss TT)
    x
        toStrokes (AssRst TT
    t Expr TT
    exp) =
            let s :: TT -> Endo [Stroke]
    s = if Expr TT -> Bool
    forall a. Expr a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Expr TT
    exp then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s TT
    t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    exp
        toStrokes (AssErr TT
    t) = TT -> Endo [Stroke]
    error TT
    t

    instance Strokable (Expr TT) where
        toStrokes :: Expr TT -> Endo [Stroke]
    toStrokes (ExprSimple TT
    x Maybe (Expr TT)
    exp) = TT -> Endo [Stroke]
    normal TT
    x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (Expr TT)
    exp
        toStrokes (ExprObj TT
    l BList (KeyValue TT)
    kvs TT
    r) =
            let s :: TT -> Endo [Stroke]
    s = [TT] -> TT -> Endo [Stroke]
    failStroker [TT
    l, TT
    r] in
            TT -> Endo [Stroke]
    s TT
    l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> (KeyValue TT -> Endo [Stroke])
    -> BList (KeyValue TT) -> Endo [Stroke]
    forall m a. Monoid m => (a -> m) -> [a] -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap KeyValue TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes BList (KeyValue TT)
    kvs Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    r
        toStrokes (ExprPrefix TT
    t Expr TT
    exp) = TT -> Endo [Stroke]
    normal TT
    t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    exp
        toStrokes (ExprNew TT
    t Expr TT
    x) = TT -> Endo [Stroke]
    normal TT
    t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    x
        toStrokes (ExprParen TT
    l Expr TT
    exp TT
    r Maybe (Expr TT)
    op) =
            let s :: TT -> Endo [Stroke]
    s = [TT] -> TT -> Endo [Stroke]
    failStroker [TT
    l, TT
    r] in
            TT -> Endo [Stroke]
    s TT
    l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    exp Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    r Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (Expr TT)
    op
        toStrokes (ExprAnonFun TT
    f Parameters TT
    ps Block TT
    blk) =
            TT -> Endo [Stroke]
    normal TT
    f Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Parameters TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Parameters TT
    ps Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Block TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Block TT
    blk
        toStrokes (ExprTypeOf TT
    t Expr TT
    x) =
            let s :: TT -> Endo [Stroke]
    s = if Expr TT -> Bool
    forall a. Expr a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Expr TT
    x then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s TT
    t Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    x
        toStrokes (ExprFunCall TT
    n ParExpr TT
    x Maybe (Expr TT)
    m) =
            let s :: TT -> Endo [Stroke]
    s = if ParExpr TT -> Bool
    forall a. ParExpr a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed ParExpr TT
    x then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s TT
    n Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> ParExpr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes ParExpr TT
    x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (Expr TT)
    m
        toStrokes (OpExpr TT
    op Expr TT
    exp) =
            let s :: TT -> Endo [Stroke]
    s = if Expr TT -> Bool
    forall a. Expr a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed Expr TT
    exp then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s TT
    op Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    exp
        toStrokes (PostExpr TT
    t) = TT -> Endo [Stroke]
    normal TT
    t
        toStrokes (ExprCond TT
    a Expr TT
    x TT
    b Expr TT
    y) =
            let s :: TT -> Endo [Stroke]
    s = [TT] -> TT -> Endo [Stroke]
    failStroker [TT
    a, TT
    b] in
            TT -> Endo [Stroke]
    s TT
    a Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    b Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    y
        toStrokes (ExprArr TT
    l Maybe (Array TT)
    x TT
    r Maybe (Expr TT)
    m) =
            let s :: TT -> Endo [Stroke]
    s = [TT] -> TT -> Endo [Stroke]
    failStroker [TT
    l, TT
    r] in
            TT -> Endo [Stroke]
    s TT
    l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (Array TT -> Endo [Stroke]) -> Maybe (Array TT) -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty Array TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (Array TT)
    x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    r Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (Expr TT -> Endo [Stroke]) -> Maybe (Expr TT) -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (Expr TT)
    m
        toStrokes (ExprErr TT
    t) = TT -> Endo [Stroke]
    error TT
    t

    instance Strokable (Parameters TT) where
        toStrokes :: Parameters TT -> Endo [Stroke]
    toStrokes (Parameters TT
    l [TT]
    ps TT
    r) = TT -> Endo [Stroke]
    normal TT
    l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> (TT -> Endo [Stroke]) -> [TT] -> Endo [Stroke]
    forall m a. Monoid m => (a -> m) -> [a] -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes [TT]
    ps Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    normal TT
    r
        toStrokes (ParErr TT
    t) = TT -> Endo [Stroke]
    error TT
    t

    instance Strokable (ParExpr TT) where
        toStrokes :: ParExpr TT -> Endo [Stroke]
    toStrokes (ParExpr TT
    l [Expr TT]
    xs TT
    r) =
            let s :: TT -> Endo [Stroke]
    s = if TT -> Bool
    isError TT
    r Bool -> Bool -> Bool
    || (Expr TT -> Bool) -> [Expr TT] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any Expr TT -> Bool
    forall a. Expr a -> Bool
    forall (f :: * -> *) t. Failable f => f t -> Bool
    hasFailed [Expr TT]
    xs
                      then TT -> Endo [Stroke]
    error
                      else TT -> Endo [Stroke]
    normal in
            TT -> Endo [Stroke]
    s TT
    l Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> (Expr TT -> Endo [Stroke]) -> [Expr TT] -> Endo [Stroke]
    forall m a. Monoid m => (a -> m) -> [a] -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes [Expr TT]
    xs Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    r
        toStrokes (ParExprErr TT
    t) = TT -> Endo [Stroke]
    error TT
    t

    instance Strokable (KeyValue TT) where
        toStrokes :: KeyValue TT -> Endo [Stroke]
    toStrokes (KeyValue TT
    n TT
    c Expr TT
    exp) =
            let s :: TT -> Endo [Stroke]
    s = [TT] -> TT -> Endo [Stroke]
    failStroker [TT
    n, TT
    c] in
            TT -> Endo [Stroke]
    s TT
    n Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> TT -> Endo [Stroke]
    s TT
    c Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    exp
        toStrokes (KeyValueErr TT
    t) = TT -> Endo [Stroke]
    error TT
    t

    instance Strokable (Tok Token) where
        toStrokes :: TT -> Endo [Stroke]
    toStrokes TT
    t = if TT -> Bool
    isError TT
    t
                          then (TT -> Stroke) -> TT -> Endo [Stroke]
    forall t a. (t -> a) -> t -> Endo [a]
    one (StyleName -> Stroke -> Stroke
    modStroke StyleName
    errorStyle (Stroke -> Stroke) -> (TT -> Stroke) -> TT -> Stroke
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TT -> Stroke
    tokenToStroke) TT
    t
                          else (TT -> Stroke) -> TT -> Endo [Stroke]
    forall t a. (t -> a) -> t -> Endo [a]
    one TT -> Stroke
    tokenToStroke TT
    t

    instance Strokable (Array TT) where
        toStrokes :: Array TT -> Endo [Stroke]
    toStrokes (ArrCont Expr TT
    x Maybe (Array TT)
    m) = Expr TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Expr TT
    x Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (Array TT -> Endo [Stroke]) -> Maybe (Array TT) -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty Array TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (Array TT)
    m
        toStrokes (ArrRest TT
    c Array TT
    a Maybe (Array TT)
    m) = TT -> Endo [Stroke]
    normal TT
    c Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Array TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Array TT
    a Endo [Stroke] -> Endo [Stroke] -> Endo [Stroke]
    forall a. Semigroup a => a -> a -> a
    <> Endo [Stroke]
    -> (Array TT -> Endo [Stroke]) -> Maybe (Array TT) -> Endo [Stroke]
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Endo [Stroke]
    forall a. Monoid a => a
    mempty Array TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Maybe (Array TT)
    m
        toStrokes (ArrErr TT
    t) = TT -> Endo [Stroke]
    error TT
    t

    -- * Helper functions.

    -- | Normal stroker.
    normal :: TT -> Endo [Stroke]
    normal :: TT -> Endo [Stroke]
    normal = (TT -> Stroke) -> TT -> Endo [Stroke]
    forall t a. (t -> a) -> t -> Endo [a]
    one TT -> Stroke
    tokenToStroke

    -- | Error stroker.
    error :: TT -> Endo [Stroke]
    error :: TT -> Endo [Stroke]
    error = (TT -> Stroke) -> TT -> Endo [Stroke]
    forall t a. (t -> a) -> t -> Endo [a]
    one (StyleName -> Stroke -> Stroke
    modStroke StyleName
    errorStyle (Stroke -> Stroke) -> (TT -> Stroke) -> TT -> Stroke
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TT -> Stroke
    tokenToStroke)

    one :: (t -> a) -> t -> Endo [a]
    one :: forall t a. (t -> a) -> t -> Endo [a]
    one t -> a
    f t
    x = ([a] -> [a]) -> Endo [a]
    forall a. (a -> a) -> Endo a
    Endo (t -> a
    f t
    x a -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :)

    -- | Given a new style and a stroke, return a stroke with the new style appended
    --   to the old one.
    modStroke :: StyleName -> Stroke -> Stroke
    modStroke :: StyleName -> Stroke -> Stroke
    modStroke StyleName
    style = (StyleName -> StyleName) -> Stroke -> Stroke
    forall a b. (a -> b) -> Span a -> Span b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (StyleName
    style StyleName -> StyleName -> StyleName
    forall a. Semigroup a => a -> a -> a
    <>)

    -- * Stroking functions

    -- | Given a list of tokens to check for errors (@xs@) and a list of tokens to
    --   stroke (@xs'@), returns normal strokes for @xs'@ if there were no errors.
    --   Otherwise returns error strokes for @xs'@.
    nError :: [TT] -> [TT] -> Endo [Stroke]
    nError :: [TT] -> [TT] -> Endo [Stroke]
    nError [TT]
    xs = (TT -> Endo [Stroke]) -> [TT] -> Endo [Stroke]
    forall m a. Monoid m => (a -> m) -> [a] -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap ([TT] -> TT -> Endo [Stroke]
    failStroker [TT]
    xs)

    -- | Given a list of @TT@, if any of them is an error, returns an error stroker,
    --   otherwise a normal stroker.  Using e.g. existentials, we could make this
    --   more general and have support for heterogeneous lists of elements which
    --   implement Failable, but I haven't had the time to fix this.
    failStroker :: [TT] -> TT -> Endo [Stroke]
    failStroker :: [TT] -> TT -> Endo [Stroke]
    failStroker [TT]
    xs = if (TT -> Bool) -> [TT] -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any TT -> Bool
    isError [TT]
    xs then TT -> Endo [Stroke]
    error else TT -> Endo [Stroke]
    normal

    -- | Given a @TT@, return a @Stroke@ for it.
    tokenToStroke :: TT -> Stroke
    tokenToStroke :: TT -> Stroke
    tokenToStroke = (Token -> StyleName) -> Span Token -> Stroke
    forall a b. (a -> b) -> Span a -> Span b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Token -> StyleName
    tokenToStyle (Span Token -> Stroke) -> (TT -> Span Token) -> TT -> Stroke
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TT -> Span Token
    forall t. Tok t -> Span t
    tokToSpan

    -- | The main stroking function.
    getStrokes :: Tree TT -> Point -> Point -> Point -> [Stroke]
    getStrokes :: Tree TT -> Point -> Point -> Point -> [Stroke]
    getStrokes Tree TT
    t0 Point
    _point Point
    _begin Point
    _end = Text -> [Stroke] -> [Stroke]
    forall a. Text -> a -> a
    trace (Char
    '\n' Char -> Text -> Text
    `T.cons` Tree TT -> Text
    forall a. Show a => a -> Text
    showT Tree TT
    t0) [Stroke]
    result
        where
          result :: [Stroke]
    result = Endo [Stroke] -> [Stroke] -> [Stroke]
    forall a. Endo a -> a -> a
    appEndo ((Statement TT -> Endo [Stroke]) -> Tree TT -> Endo [Stroke]
    forall m a. Monoid m => (a -> m) -> [a] -> m
    forall (t :: * -> *) m a.
    (Foldable t, Monoid m) =>
    (a -> m) -> t a -> m
    foldMap Statement TT -> Endo [Stroke]
    forall a. Strokable a => a -> Endo [Stroke]
    toStrokes Tree TT
    t0) []

    -- * The parser

    -- | Main parser.
    parse :: P TT (Tree TT)
    parse :: P TT (Tree TT)
    parse = Parser TT (Statement TT) -> P TT (Tree TT)
    forall a. Parser TT a -> Parser TT [a]
    forall (f :: * -> *) a. Alternative f => f a -> f [a]
    many Parser TT (Statement TT)
    statement P TT (Tree TT) -> Parser TT () -> P TT (Tree TT)
    forall a b. Parser TT a -> Parser TT b -> Parser TT a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Parser TT ()
    forall s. Parser s ()
    eof

    -- | Parser for statements such as "return", "while", "do-while", "for", etc.
    statement :: P TT (Statement TT)
    statement :: Parser TT (Statement TT)
    statement = TT -> TT -> Parameters TT -> Block TT -> Statement TT
    forall t. t -> t -> Parameters t -> Block t -> Statement t
    FunDecl (TT -> TT -> Parameters TT -> Block TT -> Statement TT)
    -> Parser TT TT
    -> Parser TT (TT -> Parameters TT -> Block TT -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    Function' Parser TT (TT -> Parameters TT -> Block TT -> Statement TT)
    -> Parser TT TT
    -> Parser TT (Parameters TT -> Block TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT TT -> Parser TT TT
    plzTok Parser TT TT
    name Parser TT (Parameters TT -> Block TT -> Statement TT)
    -> Parser TT (Parameters TT)
    -> Parser TT (Block TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Parameters TT)
    parameters Parser TT (Block TT -> Statement TT)
    -> Parser TT (Block TT) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Block TT)
    block
            Parser TT (Statement TT)
    -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> BList (VarDecAss TT) -> Semicolon TT -> Statement TT
    forall t. t -> BList (VarDecAss t) -> Semicolon t -> Statement t
    VarDecl (TT -> BList (VarDecAss TT) -> Semicolon TT -> Statement TT)
    -> Parser TT TT
    -> Parser TT (BList (VarDecAss TT) -> Semicolon TT -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    Var' Parser TT (BList (VarDecAss TT) -> Semicolon TT -> Statement TT)
    -> Parser TT (BList (VarDecAss TT))
    -> Parser TT (Semicolon TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> P TT (VarDecAss TT) -> P TT (VarDecAss TT)
    forall (f :: * -> *). Failable f => P TT (f TT) -> P TT (f TT)
    plz P TT (VarDecAss TT)
    varDecAss P TT (VarDecAss TT)
    -> Parser TT TT -> Parser TT (BList (VarDecAss TT))
    forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
    `sepBy1` Char -> Parser TT TT
    spc Char
    ',' Parser TT (Semicolon TT -> Statement TT)
    -> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Semicolon TT)
    semicolon
            Parser TT (Statement TT)
    -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Maybe (Expr TT) -> Semicolon TT -> Statement TT
    forall t. t -> Maybe (Expr t) -> Semicolon t -> Statement t
    Return  (TT -> Maybe (Expr TT) -> Semicolon TT -> Statement TT)
    -> Parser TT TT
    -> Parser TT (Maybe (Expr TT) -> Semicolon TT -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    Return' Parser TT (Maybe (Expr TT) -> Semicolon TT -> Statement TT)
    -> Parser TT (Maybe (Expr TT))
    -> Parser TT (Semicolon TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional Parser TT (Expr TT)
    expression Parser TT (Semicolon TT -> Statement TT)
    -> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Semicolon TT)
    semicolon
            Parser TT (Statement TT)
    -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> ParExpr TT -> Block TT -> Statement TT
    forall t. t -> ParExpr t -> Block t -> Statement t
    While   (TT -> ParExpr TT -> Block TT -> Statement TT)
    -> Parser TT TT
    -> Parser TT (ParExpr TT -> Block TT -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    While' Parser TT (ParExpr TT -> Block TT -> Statement TT)
    -> Parser TT (ParExpr TT) -> Parser TT (Block TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (ParExpr TT)
    parExpr Parser TT (Block TT -> Statement TT)
    -> Parser TT (Block TT) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Block TT)
    block
            Parser TT (Statement TT)
    -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT
    forall t.
    t -> Block t -> t -> ParExpr t -> Semicolon t -> Statement t
    DoWhile (TT
     -> Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT)
    -> Parser TT TT
    -> Parser
         TT (Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    Do' Parser
      TT (Block TT -> TT -> ParExpr TT -> Semicolon TT -> Statement TT)
    -> Parser TT (Block TT)
    -> Parser TT (TT -> ParExpr TT -> Semicolon TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Block TT)
    block Parser TT (TT -> ParExpr TT -> Semicolon TT -> Statement TT)
    -> Parser TT TT
    -> Parser TT (ParExpr TT -> Semicolon TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT TT -> Parser TT TT
    plzTok (Reserved -> Parser TT TT
    res Reserved
    While') Parser TT (ParExpr TT -> Semicolon TT -> Statement TT)
    -> Parser TT (ParExpr TT)
    -> Parser TT (Semicolon TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (ParExpr TT)
    parExpr Parser TT (Semicolon TT -> Statement TT)
    -> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Semicolon TT)
    semicolon
            Parser TT (Statement TT)
    -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT
    -> TT -> Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT
    forall t.
    t -> t -> Expr t -> ForContent t -> t -> Block t -> Statement t
    For     (TT
     -> TT
     -> Expr TT
     -> ForContent TT
     -> TT
     -> Block TT
     -> Statement TT)
    -> Parser TT TT
    -> Parser
         TT
         (TT -> Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    For' Parser
      TT
      (TT -> Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
    -> Parser TT TT
    -> Parser
         TT (Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    '(' Parser
      TT (Expr TT -> ForContent TT -> TT -> Block TT -> Statement TT)
    -> Parser TT (Expr TT)
    -> Parser TT (ForContent TT -> TT -> Block TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr Parser TT (ForContent TT -> TT -> Block TT -> Statement TT)
    -> Parser TT (ForContent TT)
    -> Parser TT (TT -> Block TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (ForContent TT)
    forContent
                        Parser TT (TT -> Block TT -> Statement TT)
    -> Parser TT TT -> Parser TT (Block TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    ')' Parser TT (Block TT -> Statement TT)
    -> Parser TT (Block TT) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Block TT)
    block
            Parser TT (Statement TT)
    -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT
    -> ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT
    forall t.
    t -> ParExpr t -> Block t -> Maybe (Statement t) -> Statement t
    If      (TT
     -> ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT)
    -> Parser TT TT
    -> Parser
         TT (ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    If' Parser
      TT (ParExpr TT -> Block TT -> Maybe (Statement TT) -> Statement TT)
    -> Parser TT (ParExpr TT)
    -> Parser TT (Block TT -> Maybe (Statement TT) -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (ParExpr TT)
    parExpr Parser TT (Block TT -> Maybe (Statement TT) -> Statement TT)
    -> Parser TT (Block TT)
    -> Parser TT (Maybe (Statement TT) -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Block TT)
    block Parser TT (Maybe (Statement TT) -> Statement TT)
    -> Parser TT (Maybe (Statement TT)) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Statement TT) -> Parser TT (Maybe (Statement TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional (TT -> Block TT -> Statement TT
    forall t. t -> Block t -> Statement t
    Else (TT -> Block TT -> Statement TT)
    -> Parser TT TT -> Parser TT (Block TT -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    Else' Parser TT (Block TT -> Statement TT)
    -> Parser TT (Block TT) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Block TT)
    block)
            Parser TT (Statement TT)
    -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> ParExpr TT -> Block TT -> Statement TT
    forall t. t -> ParExpr t -> Block t -> Statement t
    With    (TT -> ParExpr TT -> Block TT -> Statement TT)
    -> Parser TT TT
    -> Parser TT (ParExpr TT -> Block TT -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    With' Parser TT (ParExpr TT -> Block TT -> Statement TT)
    -> Parser TT (ParExpr TT) -> Parser TT (Block TT -> Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (ParExpr TT)
    parExpr Parser TT (Block TT -> Statement TT)
    -> Parser TT (Block TT) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Block TT)
    block
            Parser TT (Statement TT)
    -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Statement TT
    forall t. t -> Statement t
    Comm    (TT -> Statement TT) -> Parser TT TT -> Parser TT (Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT TT
    comment
            Parser TT (Statement TT)
    -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Expr TT -> Semicolon TT -> Statement TT
    forall t. Expr t -> Semicolon t -> Statement t
    Expr    (Expr TT -> Semicolon TT -> Statement TT)
    -> Parser TT (Expr TT) -> Parser TT (Semicolon TT -> Statement TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT (Expr TT)
    stmtExpr Parser TT (Semicolon TT -> Statement TT)
    -> Parser TT (Semicolon TT) -> Parser TT (Statement TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Semicolon TT)
    semicolon
        where
          forContent :: P TT (ForContent TT)
          forContent :: Parser TT (ForContent TT)
    forContent = TT -> Expr TT -> TT -> Expr TT -> ForContent TT
    forall t. t -> Expr t -> t -> Expr t -> ForContent t
    ForNormal (TT -> Expr TT -> TT -> Expr TT -> ForContent TT)
    -> Parser TT TT
    -> Parser TT (Expr TT -> TT -> Expr TT -> ForContent TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> Parser TT TT
    spc Char
    ';' Parser TT (Expr TT -> TT -> Expr TT -> ForContent TT)
    -> Parser TT (Expr TT)
    -> Parser TT (TT -> Expr TT -> ForContent TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr Parser TT (TT -> Expr TT -> ForContent TT)
    -> Parser TT TT -> Parser TT (Expr TT -> ForContent TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    ';' Parser TT (Expr TT -> ForContent TT)
    -> Parser TT (Expr TT) -> Parser TT (ForContent TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr
                   Parser TT (ForContent TT)
    -> Parser TT (ForContent TT) -> Parser TT (ForContent TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Expr TT -> ForContent TT
    forall t. t -> Expr t -> ForContent t
    ForIn     (TT -> Expr TT -> ForContent TT)
    -> Parser TT TT -> Parser TT (Expr TT -> ForContent TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    In' Parser TT (Expr TT -> ForContent TT)
    -> Parser TT (Expr TT) -> Parser TT (ForContent TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr
                   Parser TT (ForContent TT)
    -> Parser TT (ForContent TT) -> Parser TT (ForContent TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> ForContent TT
    forall t. t -> ForContent t
    ForErr    (TT -> ForContent TT) -> Parser TT TT -> Parser TT (ForContent TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    1 ((TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (Bool -> TT -> Bool
    forall a b. a -> b -> a
    const Bool
    True))
                   Parser TT (ForContent TT)
    -> Parser TT (ForContent TT) -> Parser TT (ForContent TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> ForContent TT
    forall t. t -> ForContent t
    ForErr    (TT -> ForContent TT) -> Parser TT TT -> Parser TT (ForContent TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    2 (TT -> Parser TT TT
    forall a. a -> Parser TT a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TT
    errorToken)
          varDecAss :: P TT (VarDecAss TT)
          varDecAss :: P TT (VarDecAss TT)
    varDecAss = TT -> Maybe (VarDecAss TT) -> VarDecAss TT
    forall t. t -> Maybe (VarDecAss t) -> VarDecAss t
    AssBeg (TT -> Maybe (VarDecAss TT) -> VarDecAss TT)
    -> Parser TT TT -> Parser TT (Maybe (VarDecAss TT) -> VarDecAss TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT TT
    name Parser TT (Maybe (VarDecAss TT) -> VarDecAss TT)
    -> Parser TT (Maybe (VarDecAss TT)) -> P TT (VarDecAss TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> P TT (VarDecAss TT) -> Parser TT (Maybe (VarDecAss TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional (TT -> Expr TT -> VarDecAss TT
    forall t. t -> Expr t -> VarDecAss t
    AssRst (TT -> Expr TT -> VarDecAss TT)
    -> Parser TT TT -> Parser TT (Expr TT -> VarDecAss TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Operator -> Parser TT TT
    oper Operator
    Assign' Parser TT (Expr TT -> VarDecAss TT)
    -> Parser TT (Expr TT) -> P TT (VarDecAss TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr)

    -- | Parser for "blocks", i.e. a bunch of statements wrapped in curly brackets
    --   /or/ just a single statement.
    --
    --   Note that this works for JavaScript 1.8 "lambda" style function bodies as
    --   well, e.g. "function hello() 5", since expressions are also statements and
    --   we don't require a trailing semi-colon.
    --
    --   TODO: function hello() var x; is not a valid program.
    block :: P TT (Block TT)
    block :: Parser TT (Block TT)
    block = TT -> Tree TT -> TT -> Block TT
    forall t. t -> BList (Statement t) -> t -> Block t
    Block    (TT -> Tree TT -> TT -> Block TT)
    -> Parser TT TT -> Parser TT (Tree TT -> TT -> Block TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> Parser TT TT
    spc Char
    '{' Parser TT (Tree TT -> TT -> Block TT)
    -> P TT (Tree TT) -> Parser TT (TT -> Block TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Statement TT) -> P TT (Tree TT)
    forall a. Parser TT a -> Parser TT [a]
    forall (f :: * -> *) a. Alternative f => f a -> f [a]
    many Parser TT (Statement TT)
    statement Parser TT (TT -> Block TT) -> Parser TT TT -> Parser TT (Block TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    '}'
        Parser TT (Block TT)
    -> Parser TT (Block TT) -> Parser TT (Block TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Statement TT -> Block TT
    forall t. Statement t -> Block t
    BlockOne (Statement TT -> Block TT)
    -> Parser TT (Statement TT) -> Parser TT (Block TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT (Statement TT) -> Parser TT (Statement TT)
    forall s a. Int -> P s a -> P s a
    hate Int
    1 Parser TT (Statement TT)
    statement
        Parser TT (Block TT)
    -> Parser TT (Block TT) -> Parser TT (Block TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Block TT
    forall t. t -> Block t
    BlockErr (TT -> Block TT) -> Parser TT TT -> Parser TT (Block TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    2 (TT -> Parser TT TT
    forall a. a -> Parser TT a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TT
    errorToken)

    -- | Parser for expressions which may be statements.  In reality, any expression
    --   is also a valid statement, but this is a slight compromise to get rid of
    --   the massive performance loss which is introduced when allowing JavaScript
    --   objects to be valid statements.
    stmtExpr :: P TT (Expr TT)
    stmtExpr :: Parser TT (Expr TT)
    stmtExpr = TT -> Maybe (Expr TT) -> Expr TT
    forall t. t -> Maybe (Expr t) -> Expr t
    ExprSimple (TT -> Maybe (Expr TT) -> Expr TT)
    -> Parser TT TT -> Parser TT (Maybe (Expr TT) -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT TT
    simpleTok Parser TT (Maybe (Expr TT) -> Expr TT)
    -> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional Parser TT (Expr TT)
    opExpr
           Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Expr TT -> Expr TT
    forall t. t -> Expr t -> Expr t
    ExprPrefix (TT -> Expr TT -> Expr TT)
    -> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT TT
    preOp Parser TT (Expr TT -> Expr TT)
    -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr
           Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Expr TT -> Expr TT
    forall t. t -> Expr t -> Expr t
    ExprNew    (TT -> Expr TT -> Expr TT)
    -> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    New' Parser TT (Expr TT -> Expr TT)
    -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall (f :: * -> *). Failable f => P TT (f TT) -> P TT (f TT)
    plz Parser TT (Expr TT)
    funCall
           Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Parser TT (Expr TT)
    funCall
           -- We hate the parenthesized expression just a tad because otherwise
           -- confirm('hello') will be seen as "confirm; ('hello');"
           Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Int -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall s a. Int -> P s a -> P s a
    hate Int
    1 (TT -> Expr TT -> TT -> Maybe (Expr TT) -> Expr TT
    forall t. t -> Expr t -> t -> Maybe (Expr t) -> Expr t
    ExprParen  (TT -> Expr TT -> TT -> Maybe (Expr TT) -> Expr TT)
    -> Parser TT TT
    -> Parser TT (Expr TT -> TT -> Maybe (Expr TT) -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> Parser TT TT
    spc Char
    '(' Parser TT (Expr TT -> TT -> Maybe (Expr TT) -> Expr TT)
    -> Parser TT (Expr TT)
    -> Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
    -> Parser TT TT -> Parser TT (Maybe (Expr TT) -> Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    ')'
                                  Parser TT (Maybe (Expr TT) -> Expr TT)
    -> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional Parser TT (Expr TT)
    opExpr)
           Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Expr TT
    forall t. t -> Expr t
    ExprErr (TT -> Expr TT) -> Parser TT TT -> Parser TT (Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    2 ((TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (Bool -> TT -> Bool
    forall a b. a -> b -> a
    const Bool
    True))
        where
          funCall :: P TT (Expr TT)
          funCall :: Parser TT (Expr TT)
    funCall = TT -> ParExpr TT -> Maybe (Expr TT) -> Expr TT
    forall t. t -> ParExpr t -> Maybe (Expr t) -> Expr t
    ExprFunCall (TT -> ParExpr TT -> Maybe (Expr TT) -> Expr TT)
    -> Parser TT TT
    -> Parser TT (ParExpr TT -> Maybe (Expr TT) -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT TT
    name Parser TT (ParExpr TT -> Maybe (Expr TT) -> Expr TT)
    -> Parser TT (ParExpr TT) -> Parser TT (Maybe (Expr TT) -> Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (ParExpr TT)
    parExpr Parser TT (Maybe (Expr TT) -> Expr TT)
    -> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional Parser TT (Expr TT)
    opExpr

    -- | The basic idea here is to parse "the rest" of expressions, e.g. @+ 3@ in @x
    --   + 3@ or @[i]@ in @x[i]@.  Anything which is useful in such a scenario goes
    --   here.  TODO: This accepts [], but shouldn't, since x[] is invalid.
    opExpr :: P TT (Expr TT)
    opExpr :: Parser TT (Expr TT)
    opExpr = TT -> Expr TT -> Expr TT
    forall t. t -> Expr t -> Expr t
    OpExpr   (TT -> Expr TT -> Expr TT)
    -> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT TT
    inOp Parser TT (Expr TT -> Expr TT)
    -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr
         Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Expr TT -> TT -> Expr TT -> Expr TT
    forall t. t -> Expr t -> t -> Expr t -> Expr t
    ExprCond (TT -> Expr TT -> TT -> Expr TT -> Expr TT)
    -> Parser TT TT -> Parser TT (Expr TT -> TT -> Expr TT -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> Parser TT TT
    spc Char
    '?' Parser TT (Expr TT -> TT -> Expr TT -> Expr TT)
    -> Parser TT (Expr TT) -> Parser TT (TT -> Expr TT -> Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr Parser TT (TT -> Expr TT -> Expr TT)
    -> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    ':' Parser TT (Expr TT -> Expr TT)
    -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr
         Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Expr TT
    forall t. t -> Expr t
    PostExpr (TT -> Expr TT) -> Parser TT TT -> Parser TT (Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT TT
    postOp
         Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Parser TT (Expr TT)
    array

    -- | Parser for expressions.
    expression :: P TT (Expr TT)
    expression :: Parser TT (Expr TT)
    expression = TT -> BList (KeyValue TT) -> TT -> Expr TT
    forall t. t -> BList (KeyValue t) -> t -> Expr t
    ExprObj     (TT -> BList (KeyValue TT) -> TT -> Expr TT)
    -> Parser TT TT -> Parser TT (BList (KeyValue TT) -> TT -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> Parser TT TT
    spc Char
    '{' Parser TT (BList (KeyValue TT) -> TT -> Expr TT)
    -> Parser TT (BList (KeyValue TT)) -> Parser TT (TT -> Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> P TT (KeyValue TT)
    keyValue P TT (KeyValue TT)
    -> Parser TT TT -> Parser TT (BList (KeyValue TT))
    forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
    `sepBy` Char -> Parser TT TT
    spc Char
    ',' Parser TT (TT -> Expr TT) -> Parser TT TT -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    '}'
             Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Parameters TT -> Block TT -> Expr TT
    forall t. t -> Parameters t -> Block t -> Expr t
    ExprAnonFun (TT -> Parameters TT -> Block TT -> Expr TT)
    -> Parser TT TT -> Parser TT (Parameters TT -> Block TT -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    Function' Parser TT (Parameters TT -> Block TT -> Expr TT)
    -> Parser TT (Parameters TT) -> Parser TT (Block TT -> Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Parameters TT)
    parameters Parser TT (Block TT -> Expr TT)
    -> Parser TT (Block TT) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Block TT)
    block
             Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Expr TT -> Expr TT
    forall t. t -> Expr t -> Expr t
    ExprTypeOf  (TT -> Expr TT -> Expr TT)
    -> Parser TT TT -> Parser TT (Expr TT -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Reserved -> Parser TT TT
    res Reserved
    TypeOf' Parser TT (Expr TT -> Expr TT)
    -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr
             Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Parser TT (Expr TT)
    stmtExpr
             Parser TT (Expr TT) -> Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Parser TT (Expr TT)
    array
        where
          keyValue :: P TT (KeyValue TT)
          keyValue :: P TT (KeyValue TT)
    keyValue = TT -> TT -> Expr TT -> KeyValue TT
    forall t. t -> t -> Expr t -> KeyValue t
    KeyValue    (TT -> TT -> Expr TT -> KeyValue TT)
    -> Parser TT TT -> Parser TT (TT -> Expr TT -> KeyValue TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT TT
    name Parser TT (TT -> Expr TT -> KeyValue TT)
    -> Parser TT TT -> Parser TT (Expr TT -> KeyValue TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    ':' Parser TT (Expr TT -> KeyValue TT)
    -> Parser TT (Expr TT) -> P TT (KeyValue TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr
                 P TT (KeyValue TT) -> P TT (KeyValue TT) -> P TT (KeyValue TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> KeyValue TT
    forall t. t -> KeyValue t
    KeyValueErr (TT -> KeyValue TT) -> Parser TT TT -> P TT (KeyValue TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    1 ((TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (Bool -> TT -> Bool
    forall a b. a -> b -> a
    const Bool
    True))
                 P TT (KeyValue TT) -> P TT (KeyValue TT) -> P TT (KeyValue TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> KeyValue TT
    forall t. t -> KeyValue t
    KeyValueErr (TT -> KeyValue TT) -> Parser TT TT -> P TT (KeyValue TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    2 (TT -> Parser TT TT
    forall a. a -> Parser TT a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TT
    errorToken)

    -- | Parses both empty and non-empty arrays.  Should probably be split up into
    --   further parts to allow for the separation of @[]@ and @[1, 2, 3]@.
    array :: P TT (Expr TT)
    array :: Parser TT (Expr TT)
    array = TT -> Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT
    forall t. t -> Maybe (Array t) -> t -> Maybe (Expr t) -> Expr t
    ExprArr (TT -> Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT)
    -> Parser TT TT
    -> Parser TT (Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> Parser TT TT
    spc Char
    '[' Parser TT (Maybe (Array TT) -> TT -> Maybe (Expr TT) -> Expr TT)
    -> Parser TT (Maybe (Array TT))
    -> Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Array TT) -> Parser TT (Maybe (Array TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional Parser TT (Array TT)
    arrayContents Parser TT (TT -> Maybe (Expr TT) -> Expr TT)
    -> Parser TT TT -> Parser TT (Maybe (Expr TT) -> Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    ']'
                    Parser TT (Maybe (Expr TT) -> Expr TT)
    -> Parser TT (Maybe (Expr TT)) -> Parser TT (Expr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT) -> Parser TT (Maybe (Expr TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional Parser TT (Expr TT)
    opExpr
        where
          arrayContents :: P TT (Array TT)
          arrayContents :: Parser TT (Array TT)
    arrayContents = Expr TT -> Maybe (Array TT) -> Array TT
    forall t. Expr t -> Maybe (Array t) -> Array t
    ArrCont (Expr TT -> Maybe (Array TT) -> Array TT)
    -> Parser TT (Expr TT) -> Parser TT (Maybe (Array TT) -> Array TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Parser TT (Expr TT)
    expression Parser TT (Maybe (Array TT) -> Array TT)
    -> Parser TT (Maybe (Array TT)) -> Parser TT (Array TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Array TT) -> Parser TT (Maybe (Array TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional Parser TT (Array TT)
    arrRest
          arrRest :: P TT (Array TT)
          arrRest :: Parser TT (Array TT)
    arrRest = TT -> Array TT -> Maybe (Array TT) -> Array TT
    forall t. t -> Array t -> Maybe (Array t) -> Array t
    ArrRest (TT -> Array TT -> Maybe (Array TT) -> Array TT)
    -> Parser TT TT
    -> Parser TT (Array TT -> Maybe (Array TT) -> Array TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> Parser TT TT
    spc Char
    ',' Parser TT (Array TT -> Maybe (Array TT) -> Array TT)
    -> Parser TT (Array TT) -> Parser TT (Maybe (Array TT) -> Array TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> (Parser TT (Array TT)
    arrayContents
                                         Parser TT (Array TT)
    -> Parser TT (Array TT) -> Parser TT (Array TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Array TT
    forall t. t -> Array t
    ArrErr (TT -> Array TT) -> Parser TT TT -> Parser TT (Array TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    1 ((TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (Bool -> TT -> Bool
    forall a b. a -> b -> a
    const Bool
    True))
                                         Parser TT (Array TT)
    -> Parser TT (Array TT) -> Parser TT (Array TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Array TT
    forall t. t -> Array t
    ArrErr (TT -> Array TT) -> Parser TT TT -> Parser TT (Array TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    2 (TT -> Parser TT TT
    forall a. a -> Parser TT a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TT
    errorToken))
                                        Parser TT (Maybe (Array TT) -> Array TT)
    -> Parser TT (Maybe (Array TT)) -> Parser TT (Array TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Array TT) -> Parser TT (Maybe (Array TT))
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional Parser TT (Array TT)
    arrRest

    -- * Parsing helpers

    -- | Parses a semicolon if it's there.
    semicolon :: P TT (Maybe TT)
    semicolon :: Parser TT (Semicolon TT)
    semicolon = Parser TT TT -> Parser TT (Semicolon TT)
    forall (f :: * -> *) a. Alternative f => f a -> f (Maybe a)
    optional (Parser TT TT -> Parser TT (Semicolon TT))
    -> Parser TT TT -> Parser TT (Semicolon TT)
    forall a b. (a -> b) -> a -> b
    $ Char -> Parser TT TT
    spc Char
    ';'

    -- | Parses a comma-separated list of valid identifiers.
    parameters :: P TT (Parameters TT)
    parameters :: Parser TT (Parameters TT)
    parameters = TT -> [TT] -> TT -> Parameters TT
    forall t. t -> BList t -> t -> Parameters t
    Parameters (TT -> [TT] -> TT -> Parameters TT)
    -> Parser TT TT -> Parser TT ([TT] -> TT -> Parameters TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> Parser TT TT
    spc Char
    '(' Parser TT ([TT] -> TT -> Parameters TT)
    -> Parser TT [TT] -> Parser TT (TT -> Parameters TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT TT -> Parser TT TT
    plzTok Parser TT TT
    name Parser TT TT -> Parser TT TT -> Parser TT [TT]
    forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
    `sepBy` Char -> Parser TT TT
    spc Char
    ',' Parser TT (TT -> Parameters TT)
    -> Parser TT TT -> Parser TT (Parameters TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    ')'
             Parser TT (Parameters TT)
    -> Parser TT (Parameters TT) -> Parser TT (Parameters TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Parameters TT
    forall t. t -> Parameters t
    ParErr (TT -> Parameters TT) -> Parser TT TT -> Parser TT (Parameters TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    1 ((TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (Bool -> TT -> Bool
    forall a b. a -> b -> a
    const Bool
    True))
             Parser TT (Parameters TT)
    -> Parser TT (Parameters TT) -> Parser TT (Parameters TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> Parameters TT
    forall t. t -> Parameters t
    ParErr (TT -> Parameters TT) -> Parser TT TT -> Parser TT (Parameters TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    2 (TT -> Parser TT TT
    forall a. a -> Parser TT a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TT
    errorToken)

    parExpr :: P TT (ParExpr TT)
    parExpr :: Parser TT (ParExpr TT)
    parExpr = TT -> [Expr TT] -> TT -> ParExpr TT
    forall t. t -> BList (Expr t) -> t -> ParExpr t
    ParExpr (TT -> [Expr TT] -> TT -> ParExpr TT)
    -> Parser TT TT -> Parser TT ([Expr TT] -> TT -> ParExpr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Char -> Parser TT TT
    spc Char
    '(' Parser TT ([Expr TT] -> TT -> ParExpr TT)
    -> Parser TT [Expr TT] -> Parser TT (TT -> ParExpr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Parser TT (Expr TT)
    plzExpr Parser TT (Expr TT) -> Parser TT TT -> Parser TT [Expr TT]
    forall (f :: * -> *) a v. Alternative f => f a -> f v -> f [a]
    `sepBy` Char -> Parser TT TT
    spc Char
    ',' Parser TT (TT -> ParExpr TT)
    -> Parser TT TT -> Parser TT (ParExpr TT)
    forall a b. Parser TT (a -> b) -> Parser TT a -> Parser TT b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Char -> Parser TT TT
    plzSpc Char
    ')'
          Parser TT (ParExpr TT)
    -> Parser TT (ParExpr TT) -> Parser TT (ParExpr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> ParExpr TT
    forall t. t -> ParExpr t
    ParExprErr (TT -> ParExpr TT) -> Parser TT TT -> Parser TT (ParExpr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    1 ((TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (Bool -> TT -> Bool
    forall a b. a -> b -> a
    const Bool
    True))
          Parser TT (ParExpr TT)
    -> Parser TT (ParExpr TT) -> Parser TT (ParExpr TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> ParExpr TT
    forall t. t -> ParExpr t
    ParExprErr (TT -> ParExpr TT) -> Parser TT TT -> Parser TT (ParExpr TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    2 (TT -> Parser TT TT
    forall a. a -> Parser TT a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TT
    errorToken)

    -- * Simple parsers

    -- | Parses a comment.
    comment :: P TT TT
    comment :: Parser TT TT
    comment = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                              Comment CommentType
    _ -> Bool
    True
                              Token
    _         -> Bool
    False)

    -- | Parses a prefix operator.
    preOp :: P TT TT
    preOp :: Parser TT TT
    preOp = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                            Op Operator
    x -> Operator
    x Operator -> [Operator] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Operator]
    prefixOperators
                            Token
    _    -> Bool
    False)

    -- | Parses a infix operator.
    inOp :: P TT TT
    inOp :: Parser TT TT
    inOp = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                           Op Operator
    x -> Operator
    x Operator -> [Operator] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Operator]
    infixOperators
                           Token
    _    -> Bool
    False)

    -- | Parses a postfix operator.
    postOp :: P TT TT
    postOp :: Parser TT TT
    postOp = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                             Op Operator
    x -> Operator
    x Operator -> [Operator] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Operator]
    postfixOperators
                             Token
    _    -> Bool
    False)

    -- | Parses any literal.
    opTok :: P TT TT
    opTok :: Parser TT TT
    opTok = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                            Op Operator
    _ -> Bool
    True
                            Token
    _    -> Bool
    False)

    -- | Parses any literal.
    simpleTok :: P TT TT
    simpleTok :: Parser TT TT
    simpleTok = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                Str String
    _       -> Bool
    True
                Number String
    _    -> Bool
    True
                ValidName String
    _ -> Bool
    True
                Const String
    _     -> Bool
    True
                Rex String
    _       -> Bool
    True
                Res Reserved
    y       -> Reserved
    y Reserved -> [Reserved] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Reserved
    True', Reserved
    False', Reserved
    Undefined', Reserved
    Null', Reserved
    This']
                Token
    _           -> Bool
    False)

    -- | Parses any string.
    strTok :: P TT TT
    strTok :: Parser TT TT
    strTok = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                             Str String
    _ -> Bool
    True
                             Token
    _     -> Bool
    False)

    -- | Parses any valid number.
    numTok :: P TT TT
    numTok :: Parser TT TT
    numTok = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                             Number String
    _ -> Bool
    True
                             Token
    _        -> Bool
    False)

    -- | Parses any valid identifier.
    name :: P TT TT
    name :: Parser TT TT
    name = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                           ValidName String
    _ -> Bool
    True
                           Const     String
    _ -> Bool
    True
                           Token
    _           -> Bool
    False)

    -- | Parses any boolean.
    boolean :: P TT TT
    boolean :: Parser TT TT
    boolean = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                              Res Reserved
    y -> Reserved
    y Reserved -> [Reserved] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Reserved
    True', Reserved
    False']
                              Token
    _     -> Bool
    False)

    -- | Parses a reserved word.
    res :: Reserved -> P TT TT
    res :: Reserved -> Parser TT TT
    res Reserved
    x = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                            Res Reserved
    y -> Reserved
    x Reserved -> Reserved -> Bool
    forall a. Eq a => a -> a -> Bool
    == Reserved
    y
                            Token
    _     -> Bool
    False)

    -- | Parses a special token.
    spc :: Char -> P TT TT
    spc :: Char -> Parser TT TT
    spc Char
    x = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                            Special Char
    y -> Char
    x Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    y
                            Token
    _         -> Bool
    False)

    -- | Parses an operator.
    oper :: Operator -> P TT TT
    oper :: Operator -> Parser TT TT
    oper Operator
    x = (TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (\TT
    t -> case TT -> Token
    forall t. Tok t -> t
    fromTT TT
    t of
                             Op Operator
    y -> Operator
    y Operator -> Operator -> Bool
    forall a. Eq a => a -> a -> Bool
    == Operator
    x
                             Token
    _    -> Bool
    False)

    -- * Recovery parsers

    -- | Expects a token x, recovers with 'errorToken'.
    plzTok :: P TT TT -> P TT TT
    plzTok :: Parser TT TT -> Parser TT TT
    plzTok Parser TT TT
    x = Parser TT TT
    x
           Parser TT TT -> Parser TT TT -> Parser TT TT
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    1 ((TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (Bool -> TT -> Bool
    forall a b. a -> b -> a
    const Bool
    True))
           Parser TT TT -> Parser TT TT -> Parser TT TT
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    2 (TT -> Parser TT TT
    forall a. a -> Parser TT a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TT
    errorToken)

    -- | Expects a special token.
    plzSpc :: Char -> P TT TT
    plzSpc :: Char -> Parser TT TT
    plzSpc Char
    x = Parser TT TT -> Parser TT TT
    plzTok (Char -> Parser TT TT
    spc Char
    x)

    -- | Expects an expression.
    plzExpr :: P TT (Expr TT)
    plzExpr :: Parser TT (Expr TT)
    plzExpr = Parser TT (Expr TT) -> Parser TT (Expr TT)
    forall (f :: * -> *). Failable f => P TT (f TT) -> P TT (f TT)
    plz Parser TT (Expr TT)
    expression

    plz :: Failable f => P TT (f TT) -> P TT (f TT)
    plz :: forall (f :: * -> *). Failable f => P TT (f TT) -> P TT (f TT)
    plz P TT (f TT)
    x = P TT (f TT)
    x
        P TT (f TT) -> P TT (f TT) -> P TT (f TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> f TT
    forall t. t -> f t
    forall (f :: * -> *) t. Failable f => t -> f t
    stupid (TT -> f TT) -> Parser TT TT -> P TT (f TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    1 ((TT -> Bool) -> Parser TT TT
    forall s. (s -> Bool) -> Parser s s
    symbol (Bool -> TT -> Bool
    forall a b. a -> b -> a
    const Bool
    True))
        P TT (f TT) -> P TT (f TT) -> P TT (f TT)
    forall a. Parser TT a -> Parser TT a -> Parser TT a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> TT -> f TT
    forall t. t -> f t
    forall (f :: * -> *) t. Failable f => t -> f t
    stupid (TT -> f TT) -> Parser TT TT -> P TT (f TT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Int -> Parser TT TT -> Parser TT TT
    forall s a. Int -> P s a -> P s a
    hate Int
    2 (TT -> Parser TT TT
    forall a. a -> Parser TT a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TT
    errorToken)

    -- | General recovery parser, inserts an error token.
    anything :: P s TT
    anything :: forall s. P s TT
    anything = Parser s TT -> Parser s TT
    forall s a. Parser s a -> Parser s a
    recoverWith (TT -> Parser s TT
    forall a. a -> Parser s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure TT
    errorToken)

    -- | Weighted recovery.
    hate :: Int -> P s a -> P s a
    hate :: forall s a. Int -> P s a -> P s a
    hate Int
    n = Int -> (P s a -> P s a) -> P s a -> P s a
    forall {t} {b}. (Eq t, Num t) => t -> (b -> b) -> b -> b
    power Int
    n P s a -> P s a
    forall s a. Parser s a -> Parser s a
    recoverWith
        where
          power :: t -> (b -> b) -> b -> b
    power t
    0 b -> b
    _ = b -> b
    forall a. a -> a
    id
          power t
    m b -> b
    f = b -> b
    f (b -> b) -> (b -> b) -> b -> b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . t -> (b -> b) -> b -> b
    power (t
    m t -> t -> t
    forall a. Num a => a -> a -> a
    - t
    1) b -> b
    f

    -- * Utility stuff

    fromBlock :: Block t -> [Statement t]
    fromBlock :: forall t. Block t -> [Statement t]
    fromBlock (Block t
    _ BList (Statement t)
    x t
    _) = BList (Statement t) -> BList (Statement t)
    forall a. [a] -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    toList BList (Statement t)
    x
    fromBlock (BlockOne Statement t
    x) = [Statement t
    x]
    fromBlock (BlockErr t
    _) = []

    firstTok :: Foldable f => f t -> t
    firstTok :: forall (f :: * -> *) t. Foldable f => f t -> t
    firstTok f t
    x = [t] -> t
    forall a. HasCallStack => [a] -> a
    head (f t -> [t]
    forall a. f a -> [a]
    forall (t :: * -> *) a. Foldable t => t a -> [a]
    toList f t
    x)

    errorToken :: TT
    errorToken :: TT
    errorToken = Token -> TT
    forall t. t -> Tok t
    toTT (Token -> TT) -> Token -> TT
    forall a b. (a -> b) -> a -> b
    $ Char -> Token
    Special Char
    '!'

    isError :: TT -> Bool
    isError :: TT -> Bool
    isError (Tok (Special Char
    '!') Size
    _ Posn
    _) = Bool
    True
    isError TT
    _ = Bool
    False

    -- | Better name for 'tokFromT'.
    toTT :: t -> Tok t
    toTT :: forall t. t -> Tok t
    toTT = t -> Tok t
    forall t. t -> Tok t
    tokFromT

    -- | Better name for 'tokT'.
    fromTT :: Tok t -> t
    fromTT :: forall t. Tok t -> t
    fromTT = Tok t -> t
    forall t. Tok t -> t
    tokT