    {-# LANGUAGE CPP #-}
    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE RankNTypes #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TemplateHaskell #-}

    {-|
    Module      : Text.Pretty.Simple.Internal.Expr
    Copyright   : (c) Dennis Gosnell, 2016
    License     : BSD-style (see LICENSE file)
    Maintainer  : cdep.illabout@gmail.com
    Stability   : experimental
    Portability : POSIX

    -}
    module Text.Pretty.Simple.Internal.Expr
      where

    #if __GLASGOW_HASKELL__ < 710
    -- We don't need this import for GHC 7.10 as it exports all required functions
    -- from Prelude
    import Control.Applicative
    #endif

    import Data.Data (Data)
    import Data.Typeable (Typeable)
    import GHC.Generics (Generic)

    newtype CommaSeparated a = CommaSeparated { CommaSeparated a -> [a]
    unCommaSeparated :: [a] }
      deriving (Typeable (CommaSeparated a)
    Constr
    DataType
    Typeable (CommaSeparated a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g)
     -> CommaSeparated a
     -> c (CommaSeparated a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (CommaSeparated a))
    -> (CommaSeparated a -> Constr)
    -> (CommaSeparated a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (CommaSeparated a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (CommaSeparated a)))
    -> ((forall b. Data b => b -> b)
        -> CommaSeparated a -> CommaSeparated a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> CommaSeparated a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> CommaSeparated a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> CommaSeparated a -> m (CommaSeparated a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> CommaSeparated a -> m (CommaSeparated a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> CommaSeparated a -> m (CommaSeparated a))
    -> Data (CommaSeparated a)
    CommaSeparated a -> Constr
    CommaSeparated a -> DataType
    (forall d. Data d => c (t d)) -> Maybe (c (CommaSeparated a))
    (forall b. Data b => b -> b)
    -> CommaSeparated a -> CommaSeparated a
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommaSeparated a -> c (CommaSeparated a)
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CommaSeparated a)
    forall a. Data a => Typeable (CommaSeparated a)
    forall a. Data a => CommaSeparated a -> Constr
    forall a. Data a => CommaSeparated a -> DataType
    forall a.
    Data a =>
    (forall b. Data b => b -> b)
    -> CommaSeparated a -> CommaSeparated a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> CommaSeparated a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> CommaSeparated a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CommaSeparated a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommaSeparated a -> c (CommaSeparated a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (CommaSeparated a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CommaSeparated a))
    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) -> CommaSeparated a -> u
    forall u. (forall d. Data d => d -> u) -> CommaSeparated a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CommaSeparated a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommaSeparated a -> c (CommaSeparated a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (CommaSeparated a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CommaSeparated a))
    $cCommaSeparated :: Constr
    $tCommaSeparated :: DataType
    gmapMo :: (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    gmapMp :: (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    gmapM :: (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d)
    -> CommaSeparated a -> m (CommaSeparated a)
    gmapQi :: Int -> (forall d. Data d => d -> u) -> CommaSeparated a -> u
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> CommaSeparated a -> u
    gmapQ :: (forall d. Data d => d -> u) -> CommaSeparated a -> [u]
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> CommaSeparated a -> [u]
    gmapQr :: (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r
    gmapQl :: (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CommaSeparated a -> r
    gmapT :: (forall b. Data b => b -> b)
    -> CommaSeparated a -> CommaSeparated a
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b)
    -> CommaSeparated a -> CommaSeparated a
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CommaSeparated a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (CommaSeparated a))
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (CommaSeparated a))
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (CommaSeparated a))
    dataTypeOf :: CommaSeparated a -> DataType
    $cdataTypeOf :: forall a. Data a => CommaSeparated a -> DataType
    toConstr :: CommaSeparated a -> Constr
    $ctoConstr :: forall a. Data a => CommaSeparated a -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CommaSeparated a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (CommaSeparated a)
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommaSeparated a -> c (CommaSeparated a)
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> CommaSeparated a -> c (CommaSeparated a)
    $cp1Data :: forall a. Data a => Typeable (CommaSeparated a)
    Data, CommaSeparated a -> CommaSeparated a -> Bool
    (CommaSeparated a -> CommaSeparated a -> Bool)
    -> (CommaSeparated a -> CommaSeparated a -> Bool)
    -> Eq (CommaSeparated a)
    forall a. Eq a => CommaSeparated a -> CommaSeparated a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: CommaSeparated a -> CommaSeparated a -> Bool
    $c/= :: forall a. Eq a => CommaSeparated a -> CommaSeparated a -> Bool
    == :: CommaSeparated a -> CommaSeparated a -> Bool
    $c== :: forall a. Eq a => CommaSeparated a -> CommaSeparated a -> Bool
    Eq, (forall x. CommaSeparated a -> Rep (CommaSeparated a) x)
    -> (forall x. Rep (CommaSeparated a) x -> CommaSeparated a)
    -> Generic (CommaSeparated a)
    forall x. Rep (CommaSeparated a) x -> CommaSeparated a
    forall x. CommaSeparated a -> Rep (CommaSeparated a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (CommaSeparated a) x -> CommaSeparated a
    forall a x. CommaSeparated a -> Rep (CommaSeparated a) x
    $cto :: forall a x. Rep (CommaSeparated a) x -> CommaSeparated a
    $cfrom :: forall a x. CommaSeparated a -> Rep (CommaSeparated a) x
    Generic, Int -> CommaSeparated a -> ShowS
    [CommaSeparated a] -> ShowS
    CommaSeparated a -> String
    (Int -> CommaSeparated a -> ShowS)
    -> (CommaSeparated a -> String)
    -> ([CommaSeparated a] -> ShowS)
    -> Show (CommaSeparated a)
    forall a. Show a => Int -> CommaSeparated a -> ShowS
    forall a. Show a => [CommaSeparated a] -> ShowS
    forall a. Show a => CommaSeparated a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [CommaSeparated a] -> ShowS
    $cshowList :: forall a. Show a => [CommaSeparated a] -> ShowS
    show :: CommaSeparated a -> String
    $cshow :: forall a. Show a => CommaSeparated a -> String
    showsPrec :: Int -> CommaSeparated a -> ShowS
    $cshowsPrec :: forall a. Show a => Int -> CommaSeparated a -> ShowS
    Show, Typeable)

    data Expr
      = Brackets !(CommaSeparated [Expr])
      | Braces !(CommaSeparated [Expr])
      | Parens !(CommaSeparated [Expr])
      | StringLit !String
      | CharLit !String
      | NumberLit !String
      -- ^ We could store this as a 'Rational', say, instead of a 'String'.
      -- However, we will never need to use its value for anything. Indeed, the
      -- only thing we will be doing with it is turning it /back/ into a string
      -- at some stage, so we might as well cut out the middle man and store it
      -- directly like this.
      | Other !String
      deriving (Typeable Expr
    Constr
    DataType
    Typeable Expr =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Expr -> c Expr)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c Expr)
    -> (Expr -> Constr)
    -> (Expr -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c Expr))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr))
    -> ((forall b. Data b => b -> b) -> Expr -> Expr)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Expr -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Expr -> m Expr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Expr -> m Expr)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Expr -> m Expr)
    -> Data Expr
    Expr -> Constr
    Expr -> DataType
    (forall b. Data b => b -> b) -> Expr -> Expr
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr -> c Expr
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr
    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 -> u
    forall u. (forall d. Data d => d -> u) -> Expr -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr -> c Expr
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Expr)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
    $cOther :: Constr
    $cNumberLit :: Constr
    $cCharLit :: Constr
    $cStringLit :: Constr
    $cParens :: Constr
    $cBraces :: Constr
    $cBrackets :: Constr
    $tExpr :: DataType
    gmapMo :: (forall d. Data d => d -> m d) -> Expr -> m Expr
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    gmapMp :: (forall d. Data d => d -> m d) -> Expr -> m Expr
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    gmapM :: (forall d. Data d => d -> m d) -> Expr -> m Expr
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Expr -> m Expr
    gmapQi :: Int -> (forall d. Data d => d -> u) -> Expr -> u
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Expr -> u
    gmapQ :: (forall d. Data d => d -> u) -> Expr -> [u]
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> Expr -> [u]
    gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Expr -> r
    gmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
    $cgmapT :: (forall b. Data b => b -> b) -> Expr -> Expr
    dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Expr)
    dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Expr)
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Expr)
    dataTypeOf :: Expr -> DataType
    $cdataTypeOf :: Expr -> DataType
    toConstr :: Expr -> Constr
    $ctoConstr :: Expr -> Constr
    gunfold :: (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Expr
    gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr -> c Expr
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Expr -> c Expr
    $cp1Data :: Typeable Expr
    Data, Expr -> Expr -> Bool
    (Expr -> Expr -> Bool) -> (Expr -> Expr -> Bool) -> Eq Expr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    /= :: Expr -> Expr -> Bool
    $c/= :: Expr -> Expr -> Bool
    == :: Expr -> Expr -> Bool
    $c== :: Expr -> Expr -> Bool
    Eq, (forall x. Expr -> Rep Expr x)
    -> (forall x. Rep Expr x -> Expr) -> Generic Expr
    forall x. Rep Expr x -> Expr
    forall x. Expr -> Rep Expr x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cto :: forall x. Rep Expr x -> Expr
    $cfrom :: forall x. Expr -> Rep Expr x
    Generic, Int -> Expr -> ShowS
    [Expr] -> ShowS
    Expr -> String
    (Int -> Expr -> ShowS)
    -> (Expr -> String) -> ([Expr] -> ShowS) -> Show Expr
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    showList :: [Expr] -> ShowS
    $cshowList :: [Expr] -> ShowS
    show :: Expr -> String
    $cshow :: Expr -> String
    showsPrec :: Int -> Expr -> ShowS
    $cshowsPrec :: Int -> Expr -> ShowS
    Show, Typeable)