{-# LANGUAGE CPP, DeriveDataTypeable,
             DeriveGeneric, FlexibleInstances, DefaultSignatures,
             RankNTypes, RoleAnnotations, ScopedTypeVariables,
             MagicHash, KindSignatures, PolyKinds, TypeApplications, DataKinds,
             GADTs, UnboxedTuples, UnboxedSums, TypeInType,
             Trustworthy #-}

{-# OPTIONS_GHC -fno-warn-inline-rule-shadowing #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Language.Haskell.Syntax
-- Copyright   :  (c) The University of Glasgow 2003
-- License     :  BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer  :  libraries@haskell.org
-- Stability   :  experimental
-- Portability :  portable
--
-- Abstract syntax definitions for Template Haskell.
--
-----------------------------------------------------------------------------

module Language.Haskell.TH.Syntax
    ( module Language.Haskell.TH.Syntax
      -- * Language extensions
    , module Language.Haskell.TH.LanguageExtensions
    , ForeignSrcLang(..)
    ) where

import Data.Data hiding (Fixity(..))
import Data.IORef
import System.IO.Unsafe ( unsafePerformIO )
import Control.Monad (liftM)
import Control.Monad.IO.Class (MonadIO (..))
import System.IO        ( hPutStrLn, stderr )
import Data.Char        ( isAlpha, isAlphaNum, isUpper, ord )
import Data.Int
import Data.List.NonEmpty ( NonEmpty(..) )
import Data.Void        ( Void, absurd )
import Data.Word
import Data.Ratio
import GHC.CString      ( unpackCString# )
import GHC.Generics     ( Generic )
import GHC.Types        ( Int(..), Word(..), Char(..), Double(..), Float(..),
                          TYPE, RuntimeRep(..) )
import GHC.Prim         ( Int#, Word#, Char#, Double#, Float#, Addr# )
import GHC.Lexeme       ( startsVarSym, startsVarId )
import GHC.ForeignSrcLang.Type
import Language.Haskell.TH.LanguageExtensions
import Numeric.Natural
import Prelude
import Foreign.ForeignPtr

import qualified Control.Monad.Fail as Fail

-----------------------------------------------------
--
--              The Quasi class
--
-----------------------------------------------------

class (MonadIO m, Fail.MonadFail m) => Quasi m where
  qNewName :: String -> m Name
        -- ^ Fresh names

        -- Error reporting and recovery
  qReport  :: Bool -> String -> m ()    -- ^ Report an error (True) or warning (False)
                                        -- ...but carry on; use 'fail' to stop
  qRecover :: m a -- ^ the error handler
           -> m a -- ^ action which may fail
           -> m a               -- ^ Recover from the monadic 'fail'

        -- Inspect the type-checker's environment
  qLookupName :: Bool -> String -> m (Maybe Name)
       -- True <=> type namespace, False <=> value namespace
  qReify          :: Name -> m Info
  qReifyFixity    :: Name -> m (Maybe Fixity)
  qReifyType      :: Name -> m Type
  qReifyInstances :: Name -> [Type] -> m [Dec]
       -- Is (n tys) an instance?
       -- Returns list of matching instance Decs
       --    (with empty sub-Decs)
       -- Works for classes and type functions
  qReifyRoles         :: Name -> m [Role]
  qReifyAnnotations   :: Data a => AnnLookup -> m [a]
  qReifyModule        :: Module -> m ModuleInfo
  qReifyConStrictness :: Name -> m [DecidedStrictness]

  qLocation :: m Loc

  qRunIO :: IO a -> m a
  qRunIO = IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
  -- ^ Input/output (dangerous)

  qAddDependentFile :: FilePath -> m ()

  qAddTempFile :: String -> m FilePath

  qAddTopDecls :: [Dec] -> m ()

  qAddForeignFilePath :: ForeignSrcLang -> String -> m ()

  qAddModFinalizer :: Q () -> m ()

  qAddCorePlugin :: String -> m ()

  qGetQ :: Typeable a => m (Maybe a)

  qPutQ :: Typeable a => a -> m ()

  qIsExtEnabled :: Extension -> m Bool
  qExtsEnabled :: m [Extension]

-----------------------------------------------------
--      The IO instance of Quasi
--
--  This instance is used only when running a Q
--  computation in the IO monad, usually just to
--  print the result.  There is no interesting
--  type environment, so reification isn't going to
--  work.
--
-----------------------------------------------------

instance Quasi IO where
  qNewName :: String -> IO Name
qNewName String
s = do { Uniq
n <- IORef Uniq -> (Uniq -> (Uniq, Uniq)) -> IO Uniq
forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef' IORef Uniq
counter (\Uniq
x -> (Uniq
x Uniq -> Uniq -> Uniq
forall a. Num a => a -> a -> a
+ Uniq
1, Uniq
x))
                  ; Name -> IO Name
forall (f :: * -> *) a. Applicative f => a -> f a
pure (String -> Uniq -> Name
mkNameU String
s Uniq
n) }

  qReport :: Bool -> String -> IO ()
qReport Bool
True  String
msg = Handle -> String -> IO ()
hPutStrLn Handle
stderr (String
"Template Haskell error: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
msg)
  qReport Bool
False String
msg = Handle -> String -> IO ()
hPutStrLn Handle
stderr (String
"Template Haskell error: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
msg)

  qLookupName :: Bool -> String -> IO (Maybe Name)
qLookupName Bool
_ String
_       = String -> IO (Maybe Name)
forall a. String -> IO a
badIO String
"lookupName"
  qReify :: Name -> IO Info
qReify Name
_              = String -> IO Info
forall a. String -> IO a
badIO String
"reify"
  qReifyFixity :: Name -> IO (Maybe Fixity)
qReifyFixity Name
_        = String -> IO (Maybe Fixity)
forall a. String -> IO a
badIO String
"reifyFixity"
  qReifyType :: Name -> IO Type
qReifyType Name
_          = String -> IO Type
forall a. String -> IO a
badIO String
"reifyFixity"
  qReifyInstances :: Name -> [Type] -> IO [Dec]
qReifyInstances Name
_ [Type]
_   = String -> IO [Dec]
forall a. String -> IO a
badIO String
"reifyInstances"
  qReifyRoles :: Name -> IO [Role]
qReifyRoles Name
_         = String -> IO [Role]
forall a. String -> IO a
badIO String
"reifyRoles"
  qReifyAnnotations :: AnnLookup -> IO [a]
qReifyAnnotations AnnLookup
_   = String -> IO [a]
forall a. String -> IO a
badIO String
"reifyAnnotations"
  qReifyModule :: Module -> IO ModuleInfo
qReifyModule Module
_        = String -> IO ModuleInfo
forall a. String -> IO a
badIO String
"reifyModule"
  qReifyConStrictness :: Name -> IO [DecidedStrictness]
qReifyConStrictness Name
_ = String -> IO [DecidedStrictness]
forall a. String -> IO a
badIO String
"reifyConStrictness"
  qLocation :: IO Loc
qLocation             = String -> IO Loc
forall a. String -> IO a
badIO String
"currentLocation"
  qRecover :: IO a -> IO a -> IO a
qRecover IO a
_ IO a
_          = String -> IO a
forall a. String -> IO a
badIO String
"recover" -- Maybe we could fix this?
  qAddDependentFile :: String -> IO ()
qAddDependentFile String
_   = String -> IO ()
forall a. String -> IO a
badIO String
"addDependentFile"
  qAddTempFile :: String -> IO String
qAddTempFile String
_        = String -> IO String
forall a. String -> IO a
badIO String
"addTempFile"
  qAddTopDecls :: [Dec] -> IO ()
qAddTopDecls [Dec]
_        = String -> IO ()
forall a. String -> IO a
badIO String
"addTopDecls"
  qAddForeignFilePath :: ForeignSrcLang -> String -> IO ()
qAddForeignFilePath ForeignSrcLang
_ String
_ = String -> IO ()
forall a. String -> IO a
badIO String
"addForeignFilePath"
  qAddModFinalizer :: Q () -> IO ()
qAddModFinalizer Q ()
_    = String -> IO ()
forall a. String -> IO a
badIO String
"addModFinalizer"
  qAddCorePlugin :: String -> IO ()
qAddCorePlugin String
_      = String -> IO ()
forall a. String -> IO a
badIO String
"addCorePlugin"
  qGetQ :: IO (Maybe a)
qGetQ                 = String -> IO (Maybe a)
forall a. String -> IO a
badIO String
"getQ"
  qPutQ :: a -> IO ()
qPutQ a
_               = String -> IO ()
forall a. String -> IO a
badIO String
"putQ"
  qIsExtEnabled :: Extension -> IO Bool
qIsExtEnabled Extension
_       = String -> IO Bool
forall a. String -> IO a
badIO String
"isExtEnabled"
  qExtsEnabled :: IO [Extension]
qExtsEnabled          = String -> IO [Extension]
forall a. String -> IO a
badIO String
"extsEnabled"

badIO :: String -> IO a
badIO :: String -> IO a
badIO String
op = do   { Bool -> String -> IO ()
forall (m :: * -> *). Quasi m => Bool -> String -> m ()
qReport Bool
True (String
"Can't do `" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
op String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' in the IO monad")
                ; String -> IO a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Template Haskell failure" }

-- Global variable to generate unique symbols
counter :: IORef Uniq
{-# NOINLINE counter #-}
counter :: IORef Uniq
counter = IO (IORef Uniq) -> IORef Uniq
forall a. IO a -> a
unsafePerformIO (Uniq -> IO (IORef Uniq)
forall a. a -> IO (IORef a)
newIORef Uniq
0)


-----------------------------------------------------
--
--              The Q monad
--
-----------------------------------------------------

newtype Q a = Q { Q a -> forall (m :: * -> *). Quasi m => m a
unQ :: forall m. Quasi m => m a }

-- \"Runs\" the 'Q' monad. Normal users of Template Haskell
-- should not need this function, as the splice brackets @$( ... )@
-- are the usual way of running a 'Q' computation.
--
-- This function is primarily used in GHC internals, and for debugging
-- splices by running them in 'IO'.
--
-- Note that many functions in 'Q', such as 'reify' and other compiler
-- queries, are not supported when running 'Q' in 'IO'; these operations
-- simply fail at runtime. Indeed, the only operations guaranteed to succeed
-- are 'newName', 'runIO', 'reportError' and 'reportWarning'.
runQ :: Quasi m => Q a -> m a
runQ :: Q a -> m a
runQ (Q forall (m :: * -> *). Quasi m => m a
m) = m a
forall (m :: * -> *). Quasi m => m a
m

instance Monad Q where
  Q forall (m :: * -> *). Quasi m => m a
m >>= :: Q a -> (a -> Q b) -> Q b
>>= a -> Q b
k  = (forall (m :: * -> *). Quasi m => m b) -> Q b
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (m a
forall (m :: * -> *). Quasi m => m a
m m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
x -> Q b -> forall (m :: * -> *). Quasi m => m b
forall a. Q a -> forall (m :: * -> *). Quasi m => m a
unQ (a -> Q b
k a
x))
  >> :: Q a -> Q b -> Q b
(>>) = Q a -> Q b -> Q b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
(*>)
#if !MIN_VERSION_base(4,13,0)
  fail       = Fail.fail
#endif

instance Fail.MonadFail Q where
  fail :: String -> Q a
fail String
s     = Bool -> String -> Q ()
report Bool
True String
s Q () -> Q a -> Q a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (forall (m :: * -> *). Quasi m => m a) -> Q a
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
Fail.fail String
"Q monad failure")

instance Functor Q where
  fmap :: (a -> b) -> Q a -> Q b
fmap a -> b
f (Q forall (m :: * -> *). Quasi m => m a
x) = (forall (m :: * -> *). Quasi m => m b) -> Q b
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q ((a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f m a
forall (m :: * -> *). Quasi m => m a
x)

instance Applicative Q where
  pure :: a -> Q a
pure a
x = (forall (m :: * -> *). Quasi m => m a) -> Q a
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x)
  Q forall (m :: * -> *). Quasi m => m (a -> b)
f <*> :: Q (a -> b) -> Q a -> Q b
<*> Q forall (m :: * -> *). Quasi m => m a
x = (forall (m :: * -> *). Quasi m => m b) -> Q b
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (m (a -> b)
forall (m :: * -> *). Quasi m => m (a -> b)
f m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m a
forall (m :: * -> *). Quasi m => m a
x)
  Q forall (m :: * -> *). Quasi m => m a
m *> :: Q a -> Q b -> Q b
*> Q forall (m :: * -> *). Quasi m => m b
n = (forall (m :: * -> *). Quasi m => m b) -> Q b
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (m a
forall (m :: * -> *). Quasi m => m a
m m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m b
forall (m :: * -> *). Quasi m => m b
n)

-----------------------------------------------------
--
--              The TExp type
--
-----------------------------------------------------

type role TExp nominal   -- See Note [Role of TExp]
newtype TExp (a :: TYPE (r :: RuntimeRep)) = TExp
  { TExp a -> Exp
unType :: Exp -- ^ Underlying untyped Template Haskell expression
  }
-- ^ Represents an expression which has type @a@. Built on top of 'Exp', typed
-- expressions allow for type-safe splicing via:
--
--   - typed quotes, written as @[|| ... ||]@ where @...@ is an expression; if
--     that expression has type @a@, then the quotation has type
--     @'Q' ('TExp' a)@
--
--   - typed splices inside of typed quotes, written as @$$(...)@ where @...@
--     is an arbitrary expression of type @'Q' ('TExp' a)@
--
-- Traditional expression quotes and splices let us construct ill-typed
-- expressions:
--
-- >>> fmap ppr $ runQ [| True == $( [| "foo" |] ) |]
-- GHC.Types.True GHC.Classes.== "foo"
-- >>> GHC.Types.True GHC.Classes.== "foo"
-- <interactive> error:
--     • Couldn't match expected type ‘Bool’ with actual type ‘[Char]’
--     • In the second argument of ‘(==)’, namely ‘"foo"’
--       In the expression: True == "foo"
--       In an equation for ‘it’: it = True == "foo"
--
-- With typed expressions, the type error occurs when /constructing/ the
-- Template Haskell expression:
--
-- >>> fmap ppr $ runQ [|| True == $$( [|| "foo" ||] ) ||]
-- <interactive> error:
--     • Couldn't match type ‘[Char]’ with ‘Bool’
--       Expected type: Q (TExp Bool)
--         Actual type: Q (TExp [Char])
--     • In the Template Haskell quotation [|| "foo" ||]
--       In the expression: [|| "foo" ||]
--       In the Template Haskell splice $$([|| "foo" ||])

-- | Discard the type annotation and produce a plain Template Haskell
-- expression
--
-- Levity-polymorphic since /template-haskell-2.16.0.0/.
unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r). Q (TExp a) -> Q Exp
unTypeQ :: Q (TExp a) -> Q Exp
unTypeQ Q (TExp a)
m = do { TExp Exp
e <- Q (TExp a)
m
               ; Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return Exp
e }

-- | Annotate the Template Haskell expression with a type
--
-- This is unsafe because GHC cannot check for you that the expression
-- really does have the type you claim it has.
--
-- Levity-polymorphic since /template-haskell-2.16.0.0/.
unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r). Q Exp -> Q (TExp a)
unsafeTExpCoerce :: Q Exp -> Q (TExp a)
unsafeTExpCoerce Q Exp
m = do { Exp
e <- Q Exp
m
                        ; TExp a -> Q (TExp a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TExp a
forall a. Exp -> TExp a
TExp Exp
e) }

{- Note [Role of TExp]
~~~~~~~~~~~~~~~~~~~~~~
TExp's argument must have a nominal role, not phantom as would
be inferred (#8459).  Consider

  e :: TExp Age
  e = MkAge 3

  foo = $(coerce e) + 4::Int

The splice will evaluate to (MkAge 3) and you can't add that to
4::Int. So you can't coerce a (TExp Age) to a (TExp Int). -}

----------------------------------------------------
-- Packaged versions for the programmer, hiding the Quasi-ness

{- |
Generate a fresh name, which cannot be captured.

For example, this:

@f = $(do
  nm1 <- newName \"x\"
  let nm2 = 'mkName' \"x\"
  return ('LamE' ['VarP' nm1] (LamE [VarP nm2] ('VarE' nm1)))
 )@

will produce the splice

>f = \x0 -> \x -> x0

In particular, the occurrence @VarE nm1@ refers to the binding @VarP nm1@,
and is not captured by the binding @VarP nm2@.

Although names generated by @newName@ cannot /be captured/, they can
/capture/ other names. For example, this:

>g = $(do
>  nm1 <- newName "x"
>  let nm2 = mkName "x"
>  return (LamE [VarP nm2] (LamE [VarP nm1] (VarE nm2)))
> )

will produce the splice

>g = \x -> \x0 -> x0

since the occurrence @VarE nm2@ is captured by the innermost binding
of @x@, namely @VarP nm1@.
-}
newName :: String -> Q Name
newName :: String -> Q Name
newName String
s = (forall (m :: * -> *). Quasi m => m Name) -> Q Name
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m Name
forall (m :: * -> *). Quasi m => String -> m Name
qNewName String
s)

-- | Report an error (True) or warning (False),
-- but carry on; use 'fail' to stop.
report  :: Bool -> String -> Q ()
report :: Bool -> String -> Q ()
report Bool
b String
s = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Bool -> String -> m ()
forall (m :: * -> *). Quasi m => Bool -> String -> m ()
qReport Bool
b String
s)
{-# DEPRECATED report "Use reportError or reportWarning instead" #-} -- deprecated in 7.6

-- | Report an error to the user, but allow the current splice's computation to carry on. To abort the computation, use 'fail'.
reportError :: String -> Q ()
reportError :: String -> Q ()
reportError = Bool -> String -> Q ()
report Bool
True

-- | Report a warning to the user, and carry on.
reportWarning :: String -> Q ()
reportWarning :: String -> Q ()
reportWarning = Bool -> String -> Q ()
report Bool
False

-- | Recover from errors raised by 'reportError' or 'fail'.
recover :: Q a -- ^ handler to invoke on failure
        -> Q a -- ^ computation to run
        -> Q a
recover :: Q a -> Q a -> Q a
recover (Q forall (m :: * -> *). Quasi m => m a
r) (Q forall (m :: * -> *). Quasi m => m a
m) = (forall (m :: * -> *). Quasi m => m a) -> Q a
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (m a -> m a -> m a
forall (m :: * -> *) a. Quasi m => m a -> m a -> m a
qRecover m a
forall (m :: * -> *). Quasi m => m a
r m a
forall (m :: * -> *). Quasi m => m a
m)

-- We don't export lookupName; the Bool isn't a great API
-- Instead we export lookupTypeName, lookupValueName
lookupName :: Bool -> String -> Q (Maybe Name)
lookupName :: Bool -> String -> Q (Maybe Name)
lookupName Bool
ns String
s = (forall (m :: * -> *). Quasi m => m (Maybe Name)) -> Q (Maybe Name)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Bool -> String -> m (Maybe Name)
forall (m :: * -> *). Quasi m => Bool -> String -> m (Maybe Name)
qLookupName Bool
ns String
s)

-- | Look up the given name in the (type namespace of the) current splice's scope. See "Language.Haskell.TH.Syntax#namelookup" for more details.
lookupTypeName :: String -> Q (Maybe Name)
lookupTypeName :: String -> Q (Maybe Name)
lookupTypeName  String
s = (forall (m :: * -> *). Quasi m => m (Maybe Name)) -> Q (Maybe Name)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Bool -> String -> m (Maybe Name)
forall (m :: * -> *). Quasi m => Bool -> String -> m (Maybe Name)
qLookupName Bool
True String
s)

-- | Look up the given name in the (value namespace of the) current splice's scope. See "Language.Haskell.TH.Syntax#namelookup" for more details.
lookupValueName :: String -> Q (Maybe Name)
lookupValueName :: String -> Q (Maybe Name)
lookupValueName String
s = (forall (m :: * -> *). Quasi m => m (Maybe Name)) -> Q (Maybe Name)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Bool -> String -> m (Maybe Name)
forall (m :: * -> *). Quasi m => Bool -> String -> m (Maybe Name)
qLookupName Bool
False String
s)

{-
Note [Name lookup]
~~~~~~~~~~~~~~~~~~
-}
{- $namelookup #namelookup#
The functions 'lookupTypeName' and 'lookupValueName' provide
a way to query the current splice's context for what names
are in scope. The function 'lookupTypeName' queries the type
namespace, whereas 'lookupValueName' queries the value namespace,
but the functions are otherwise identical.

A call @lookupValueName s@ will check if there is a value
with name @s@ in scope at the current splice's location. If
there is, the @Name@ of this value is returned;
if not, then @Nothing@ is returned.

The returned name cannot be \"captured\".
For example:

> f = "global"
> g = $( do
>          Just nm <- lookupValueName "f"
>          [| let f = "local" in $( varE nm ) |]

In this case, @g = \"global\"@; the call to @lookupValueName@
returned the global @f@, and this name was /not/ captured by
the local definition of @f@.

The lookup is performed in the context of the /top-level/ splice
being run. For example:

> f = "global"
> g = $( [| let f = "local" in
>            $(do
>                Just nm <- lookupValueName "f"
>                varE nm
>             ) |] )

Again in this example, @g = \"global\"@, because the call to
@lookupValueName@ queries the context of the outer-most @$(...)@.

Operators should be queried without any surrounding parentheses, like so:

> lookupValueName "+"

Qualified names are also supported, like so:

> lookupValueName "Prelude.+"
> lookupValueName "Prelude.map"

-}


{- | 'reify' looks up information about the 'Name'.

It is sometimes useful to construct the argument name using 'lookupTypeName' or 'lookupValueName'
to ensure that we are reifying from the right namespace. For instance, in this context:

> data D = D

which @D@ does @reify (mkName \"D\")@ return information about? (Answer: @D@-the-type, but don't rely on it.)
To ensure we get information about @D@-the-value, use 'lookupValueName':

> do
>   Just nm <- lookupValueName "D"
>   reify nm

and to get information about @D@-the-type, use 'lookupTypeName'.
-}
reify :: Name -> Q Info
reify :: Name -> Q Info
reify Name
v = (forall (m :: * -> *). Quasi m => m Info) -> Q Info
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m Info
forall (m :: * -> *). Quasi m => Name -> m Info
qReify Name
v)

{- | @reifyFixity nm@ attempts to find a fixity declaration for @nm@. For
example, if the function @foo@ has the fixity declaration @infixr 7 foo@, then
@reifyFixity 'foo@ would return @'Just' ('Fixity' 7 'InfixR')@. If the function
@bar@ does not have a fixity declaration, then @reifyFixity 'bar@ returns
'Nothing', so you may assume @bar@ has 'defaultFixity'.
-}
reifyFixity :: Name -> Q (Maybe Fixity)
reifyFixity :: Name -> Q (Maybe Fixity)
reifyFixity Name
nm = (forall (m :: * -> *). Quasi m => m (Maybe Fixity))
-> Q (Maybe Fixity)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m (Maybe Fixity)
forall (m :: * -> *). Quasi m => Name -> m (Maybe Fixity)
qReifyFixity Name
nm)

{- | @reifyType nm@ attempts to find the type or kind of @nm@. For example,
@reifyType 'not@   returns @Bool -> Bool@, and
@reifyType ''Bool@ returns @Type@.
This works even if there's no explicit signature and the type or kind is inferred.
-}
reifyType :: Name -> Q Type
reifyType :: Name -> Q Type
reifyType Name
nm = (forall (m :: * -> *). Quasi m => m Type) -> Q Type
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m Type
forall (m :: * -> *). Quasi m => Name -> m Type
qReifyType Name
nm)

{- | @reifyInstances nm tys@ returns a list of visible instances of @nm tys@. That is,
if @nm@ is the name of a type class, then all instances of this class at the types @tys@
are returned. Alternatively, if @nm@ is the name of a data family or type family,
all instances of this family at the types @tys@ are returned.

Note that this is a \"shallow\" test; the declarations returned merely have
instance heads which unify with @nm tys@, they need not actually be satisfiable.

  - @reifyInstances ''Eq [ 'TupleT' 2 \``AppT`\` 'ConT' ''A \``AppT`\` 'ConT' ''B ]@ contains
    the @instance (Eq a, Eq b) => Eq (a, b)@ regardless of whether @A@ and
    @B@ themselves implement 'Eq'

  - @reifyInstances ''Show [ 'VarT' ('mkName' "a") ]@ produces every available
    instance of 'Eq'

There is one edge case: @reifyInstances ''Typeable tys@ currently always
produces an empty list (no matter what @tys@ are given).
-}
reifyInstances :: Name -> [Type] -> Q [InstanceDec]
reifyInstances :: Name -> [Type] -> Q [Dec]
reifyInstances Name
cls [Type]
tys = (forall (m :: * -> *). Quasi m => m [Dec]) -> Q [Dec]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> [Type] -> m [Dec]
forall (m :: * -> *). Quasi m => Name -> [Type] -> m [Dec]
qReifyInstances Name
cls [Type]
tys)

{- | @reifyRoles nm@ returns the list of roles associated with the parameters of
the tycon @nm@. Fails if @nm@ cannot be found or is not a tycon.
The returned list should never contain 'InferR'.
-}
reifyRoles :: Name -> Q [Role]
reifyRoles :: Name -> Q [Role]
reifyRoles Name
nm = (forall (m :: * -> *). Quasi m => m [Role]) -> Q [Role]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m [Role]
forall (m :: * -> *). Quasi m => Name -> m [Role]
qReifyRoles Name
nm)

-- | @reifyAnnotations target@ returns the list of annotations
-- associated with @target@.  Only the annotations that are
-- appropriately typed is returned.  So if you have @Int@ and @String@
-- annotations for the same target, you have to call this function twice.
reifyAnnotations :: Data a => AnnLookup -> Q [a]
reifyAnnotations :: AnnLookup -> Q [a]
reifyAnnotations AnnLookup
an = (forall (m :: * -> *). Quasi m => m [a]) -> Q [a]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (AnnLookup -> m [a]
forall (m :: * -> *) a. (Quasi m, Data a) => AnnLookup -> m [a]
qReifyAnnotations AnnLookup
an)

-- | @reifyModule mod@ looks up information about module @mod@.  To
-- look up the current module, call this function with the return
-- value of 'Language.Haskell.TH.Lib.thisModule'.
reifyModule :: Module -> Q ModuleInfo
reifyModule :: Module -> Q ModuleInfo
reifyModule Module
m = (forall (m :: * -> *). Quasi m => m ModuleInfo) -> Q ModuleInfo
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Module -> m ModuleInfo
forall (m :: * -> *). Quasi m => Module -> m ModuleInfo
qReifyModule Module
m)

-- | @reifyConStrictness nm@ looks up the strictness information for the fields
-- of the constructor with the name @nm@. Note that the strictness information
-- that 'reifyConStrictness' returns may not correspond to what is written in
-- the source code. For example, in the following data declaration:
--
-- @
-- data Pair a = Pair a a
-- @
--
-- 'reifyConStrictness' would return @['DecidedLazy', DecidedLazy]@ under most
-- circumstances, but it would return @['DecidedStrict', DecidedStrict]@ if the
-- @-XStrictData@ language extension was enabled.
reifyConStrictness :: Name -> Q [DecidedStrictness]
reifyConStrictness :: Name -> Q [DecidedStrictness]
reifyConStrictness Name
n = (forall (m :: * -> *). Quasi m => m [DecidedStrictness])
-> Q [DecidedStrictness]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Name -> m [DecidedStrictness]
forall (m :: * -> *). Quasi m => Name -> m [DecidedStrictness]
qReifyConStrictness Name
n)

-- | Is the list of instances returned by 'reifyInstances' nonempty?
isInstance :: Name -> [Type] -> Q Bool
isInstance :: Name -> [Type] -> Q Bool
isInstance Name
nm [Type]
tys = do { [Dec]
decs <- Name -> [Type] -> Q [Dec]
reifyInstances Name
nm [Type]
tys
                       ; Bool -> Q Bool
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Bool
not ([Dec] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Dec]
decs)) }

-- | The location at which this computation is spliced.
location :: Q Loc
location :: Q Loc
location = (forall (m :: * -> *). Quasi m => m Loc) -> Q Loc
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q forall (m :: * -> *). Quasi m => m Loc
qLocation

-- |The 'runIO' function lets you run an I\/O computation in the 'Q' monad.
-- Take care: you are guaranteed the ordering of calls to 'runIO' within
-- a single 'Q' computation, but not about the order in which splices are run.
--
-- Note: for various murky reasons, stdout and stderr handles are not
-- necessarily flushed when the compiler finishes running, so you should
-- flush them yourself.
runIO :: IO a -> Q a
runIO :: IO a -> Q a
runIO IO a
m = (forall (m :: * -> *). Quasi m => m a) -> Q a
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (IO a -> m a
forall (m :: * -> *) a. Quasi m => IO a -> m a
qRunIO IO a
m)

-- | Record external files that runIO is using (dependent upon).
-- The compiler can then recognize that it should re-compile the Haskell file
-- when an external file changes.
--
-- Expects an absolute file path.
--
-- Notes:
--
--   * ghc -M does not know about these dependencies - it does not execute TH.
--
--   * The dependency is based on file content, not a modification time
addDependentFile :: FilePath -> Q ()
addDependentFile :: String -> Q ()
addDependentFile String
fp = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m ()
forall (m :: * -> *). Quasi m => String -> m ()
qAddDependentFile String
fp)

-- | Obtain a temporary file path with the given suffix. The compiler will
-- delete this file after compilation.
addTempFile :: String -> Q FilePath
addTempFile :: String -> Q String
addTempFile String
suffix = (forall (m :: * -> *). Quasi m => m String) -> Q String
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m String
forall (m :: * -> *). Quasi m => String -> m String
qAddTempFile String
suffix)

-- | Add additional top-level declarations. The added declarations will be type
-- checked along with the current declaration group.
addTopDecls :: [Dec] -> Q ()
addTopDecls :: [Dec] -> Q ()
addTopDecls [Dec]
ds = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q ([Dec] -> m ()
forall (m :: * -> *). Quasi m => [Dec] -> m ()
qAddTopDecls [Dec]
ds)

-- |
addForeignFile :: ForeignSrcLang -> String -> Q ()
addForeignFile :: ForeignSrcLang -> String -> Q ()
addForeignFile = ForeignSrcLang -> String -> Q ()
addForeignSource
{-# DEPRECATED addForeignFile
               "Use 'Language.Haskell.TH.Syntax.addForeignSource' instead"
  #-} -- deprecated in 8.6

-- | Emit a foreign file which will be compiled and linked to the object for
-- the current module. Currently only languages that can be compiled with
-- the C compiler are supported, and the flags passed as part of -optc will
-- be also applied to the C compiler invocation that will compile them.
--
-- Note that for non-C languages (for example C++) @extern "C"@ directives
-- must be used to get symbols that we can access from Haskell.
--
-- To get better errors, it is recommended to use #line pragmas when
-- emitting C files, e.g.
--
-- > {-# LANGUAGE CPP #-}
-- > ...
-- > addForeignSource LangC $ unlines
-- >   [ "#line " ++ show (__LINE__ + 1) ++ " " ++ show __FILE__
-- >   , ...
-- >   ]
addForeignSource :: ForeignSrcLang -> String -> Q ()
addForeignSource :: ForeignSrcLang -> String -> Q ()
addForeignSource ForeignSrcLang
lang String
src = do
  let suffix :: String
suffix = case ForeignSrcLang
lang of
                 ForeignSrcLang
LangC      -> String
"c"
                 ForeignSrcLang
LangCxx    -> String
"cpp"
                 ForeignSrcLang
LangObjc   -> String
"m"
                 ForeignSrcLang
LangObjcxx -> String
"mm"
                 ForeignSrcLang
LangAsm    -> String
"s"
                 ForeignSrcLang
RawObject  -> String
"a"
  String
path <- String -> Q String
addTempFile String
suffix
  IO () -> Q ()
forall a. IO a -> Q a
runIO (IO () -> Q ()) -> IO () -> Q ()
forall a b. (a -> b) -> a -> b
$ String -> String -> IO ()
writeFile String
path String
src
  ForeignSrcLang -> String -> Q ()
addForeignFilePath ForeignSrcLang
lang String
path

-- | Same as 'addForeignSource', but expects to receive a path pointing to the
-- foreign file instead of a 'String' of its contents. Consider using this in
-- conjunction with 'addTempFile'.
--
-- This is a good alternative to 'addForeignSource' when you are trying to
-- directly link in an object file.
addForeignFilePath :: ForeignSrcLang -> FilePath -> Q ()
addForeignFilePath :: ForeignSrcLang -> String -> Q ()
addForeignFilePath ForeignSrcLang
lang String
fp = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (ForeignSrcLang -> String -> m ()
forall (m :: * -> *). Quasi m => ForeignSrcLang -> String -> m ()
qAddForeignFilePath ForeignSrcLang
lang String
fp)

-- | Add a finalizer that will run in the Q monad after the current module has
-- been type checked. This only makes sense when run within a top-level splice.
--
-- The finalizer is given the local type environment at the splice point. Thus
-- 'reify' is able to find the local definitions when executed inside the
-- finalizer.
addModFinalizer :: Q () -> Q ()
addModFinalizer :: Q () -> Q ()
addModFinalizer Q ()
act = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Q () -> m ()
forall (m :: * -> *). Quasi m => Q () -> m ()
qAddModFinalizer (Q () -> forall (m :: * -> *). Quasi m => m ()
forall a. Q a -> forall (m :: * -> *). Quasi m => m a
unQ Q ()
act))

-- | Adds a core plugin to the compilation pipeline.
--
-- @addCorePlugin m@ has almost the same effect as passing @-fplugin=m@ to ghc
-- in the command line. The major difference is that the plugin module @m@
-- must not belong to the current package. When TH executes, it is too late
-- to tell the compiler that we needed to compile first a plugin module in the
-- current package.
addCorePlugin :: String -> Q ()
addCorePlugin :: String -> Q ()
addCorePlugin String
plugin = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (String -> m ()
forall (m :: * -> *). Quasi m => String -> m ()
qAddCorePlugin String
plugin)

-- | Get state from the 'Q' monad. Note that the state is local to the
-- Haskell module in which the Template Haskell expression is executed.
getQ :: Typeable a => Q (Maybe a)
getQ :: Q (Maybe a)
getQ = (forall (m :: * -> *). Quasi m => m (Maybe a)) -> Q (Maybe a)
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q forall (m :: * -> *). Quasi m => m (Maybe a)
forall (m :: * -> *) a. (Quasi m, Typeable a) => m (Maybe a)
qGetQ

-- | Replace the state in the 'Q' monad. Note that the state is local to the
-- Haskell module in which the Template Haskell expression is executed.
putQ :: Typeable a => a -> Q ()
putQ :: a -> Q ()
putQ a
x = (forall (m :: * -> *). Quasi m => m ()) -> Q ()
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (a -> m ()
forall (m :: * -> *) a. (Quasi m, Typeable a) => a -> m ()
qPutQ a
x)

-- | Determine whether the given language extension is enabled in the 'Q' monad.
isExtEnabled :: Extension -> Q Bool
isExtEnabled :: Extension -> Q Bool
isExtEnabled Extension
ext = (forall (m :: * -> *). Quasi m => m Bool) -> Q Bool
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q (Extension -> m Bool
forall (m :: * -> *). Quasi m => Extension -> m Bool
qIsExtEnabled Extension
ext)

-- | List all enabled language extensions.
extsEnabled :: Q [Extension]
extsEnabled :: Q [Extension]
extsEnabled = (forall (m :: * -> *). Quasi m => m [Extension]) -> Q [Extension]
forall a. (forall (m :: * -> *). Quasi m => m a) -> Q a
Q forall (m :: * -> *). Quasi m => m [Extension]
qExtsEnabled

instance MonadIO Q where
  liftIO :: IO a -> Q a
liftIO = IO a -> Q a
forall a. IO a -> Q a
runIO

instance Quasi Q where
  qNewName :: String -> Q Name
qNewName            = String -> Q Name
newName
  qReport :: Bool -> String -> Q ()
qReport             = Bool -> String -> Q ()
report
  qRecover :: Q a -> Q a -> Q a
qRecover            = Q a -> Q a -> Q a
forall a. Q a -> Q a -> Q a
recover
  qReify :: Name -> Q Info
qReify              = Name -> Q Info
reify
  qReifyFixity :: Name -> Q (Maybe Fixity)
qReifyFixity        = Name -> Q (Maybe Fixity)
reifyFixity
  qReifyType :: Name -> Q Type
qReifyType          = Name -> Q Type
reifyType
  qReifyInstances :: Name -> [Type] -> Q [Dec]
qReifyInstances     = Name -> [Type] -> Q [Dec]
reifyInstances
  qReifyRoles :: Name -> Q [Role]
qReifyRoles         = Name -> Q [Role]
reifyRoles
  qReifyAnnotations :: AnnLookup -> Q [a]
qReifyAnnotations   = AnnLookup -> Q [a]
forall a. Data a => AnnLookup -> Q [a]
reifyAnnotations
  qReifyModule :: Module -> Q ModuleInfo
qReifyModule        = Module -> Q ModuleInfo
reifyModule
  qReifyConStrictness :: Name -> Q [DecidedStrictness]
qReifyConStrictness = Name -> Q [DecidedStrictness]
reifyConStrictness
  qLookupName :: Bool -> String -> Q (Maybe Name)
qLookupName         = Bool -> String -> Q (Maybe Name)
lookupName
  qLocation :: Q Loc
qLocation           = Q Loc
location
  qAddDependentFile :: String -> Q ()
qAddDependentFile   = String -> Q ()
addDependentFile
  qAddTempFile :: String -> Q String
qAddTempFile        = String -> Q String
addTempFile
  qAddTopDecls :: [Dec] -> Q ()
qAddTopDecls        = [Dec] -> Q ()
addTopDecls
  qAddForeignFilePath :: ForeignSrcLang -> String -> Q ()
qAddForeignFilePath = ForeignSrcLang -> String -> Q ()
addForeignFilePath
  qAddModFinalizer :: Q () -> Q ()
qAddModFinalizer    = Q () -> Q ()
addModFinalizer
  qAddCorePlugin :: String -> Q ()
qAddCorePlugin      = String -> Q ()
addCorePlugin
  qGetQ :: Q (Maybe a)
qGetQ               = Q (Maybe a)
forall a. Typeable a => Q (Maybe a)
getQ
  qPutQ :: a -> Q ()
qPutQ               = a -> Q ()
forall a. Typeable a => a -> Q ()
putQ
  qIsExtEnabled :: Extension -> Q Bool
qIsExtEnabled       = Extension -> Q Bool
isExtEnabled
  qExtsEnabled :: Q [Extension]
qExtsEnabled        = Q [Extension]
extsEnabled


----------------------------------------------------
-- The following operations are used solely in DsMeta when desugaring brackets
-- They are not necessary for the user, who can use ordinary return and (>>=) etc

returnQ :: a -> Q a
returnQ :: a -> Q a
returnQ = a -> Q a
forall (m :: * -> *) a. Monad m => a -> m a
return

bindQ :: Q a -> (a -> Q b) -> Q b
bindQ :: Q a -> (a -> Q b) -> Q b
bindQ = Q a -> (a -> Q b) -> Q b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(>>=)

sequenceQ :: [Q a] -> Q [a]
sequenceQ :: [Q a] -> Q [a]
sequenceQ = [Q a] -> Q [a]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence


-----------------------------------------------------
--
--              The Lift class
--
-----------------------------------------------------

-- | A 'Lift' instance can have any of its values turned into a Template
-- Haskell expression. This is needed when a value used within a Template
-- Haskell quotation is bound outside the Oxford brackets (@[| ... |]@ or
-- @[|| ... ||]@) but not at the top level. As an example:
--
-- > add1 :: Int -> Q (TExp Int)
-- > add1 x = [|| x + 1 ||]
--
-- Template Haskell has no way of knowing what value @x@ will take on at
-- splice-time, so it requires the type of @x@ to be an instance of 'Lift'.
--
-- A 'Lift' instance must satisfy @$(lift x) ≡ x@ and @$$(liftTyped x) ≡ x@
-- for all @x@, where @$(...)@ and @$$(...)@ are Template Haskell splices.
-- It is additionally expected that @'lift' x ≡ 'unTypeQ' ('liftTyped' x)@.
--
-- 'Lift' instances can be derived automatically by use of the @-XDeriveLift@
-- GHC language extension:
--
-- > {-# LANGUAGE DeriveLift #-}
-- > module Foo where
-- >
-- > import Language.Haskell.TH.Syntax
-- >
-- > data Bar a = Bar1 a (Bar a) | Bar2 String
-- >   deriving Lift
--
-- Levity-polymorphic since /template-haskell-2.16.0.0/.
class Lift (t :: TYPE r) where
  -- | Turn a value into a Template Haskell expression, suitable for use in
  -- a splice.
  lift :: t -> Q Exp
  default lift :: (r ~ 'LiftedRep) => t -> Q Exp
  lift = Q (TExp t) -> Q Exp
forall a. Q (TExp a) -> Q Exp
unTypeQ (Q (TExp t) -> Q Exp) -> (t -> Q (TExp t)) -> t -> Q Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> Q (TExp t)
forall t. Lift t => t -> Q (TExp t)
liftTyped

  -- | Turn a value into a Template Haskell typed expression, suitable for use
  -- in a typed splice.
  --
  -- @since 2.16.0.0
  liftTyped :: t -> Q (TExp t)


-- If you add any instances here, consider updating test th/TH_Lift
instance Lift Integer where
  liftTyped :: Uniq -> Q (TExp Uniq)
liftTyped Uniq
x = Q Exp -> Q (TExp Uniq)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Uniq -> Q Exp
forall t. Lift t => t -> Q Exp
lift Uniq
x)
  lift :: Uniq -> Q Exp
lift Uniq
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL Uniq
x))

instance Lift Int where
  liftTyped :: Int -> Q (TExp Int)
liftTyped Int
x = Q Exp -> Q (TExp Int)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int
x)
  lift :: Int -> Q Exp
lift Int
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
x)))

-- | @since 2.16.0.0
instance Lift Int# where
  liftTyped :: Int# -> Q (TExp Int#)
liftTyped Int#
x = Q Exp -> Q (TExp Int#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int#
x)
  lift :: Int# -> Q Exp
lift Int#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntPrimL (Int -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int# -> Int
I# Int#
x))))

instance Lift Int8 where
  liftTyped :: Int8 -> Q (TExp Int8)
liftTyped Int8
x = Q Exp -> Q (TExp Int8)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int8 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int8
x)
  lift :: Int8 -> Q Exp
lift Int8
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int8 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int8
x)))

instance Lift Int16 where
  liftTyped :: Int16 -> Q (TExp Int16)
liftTyped Int16
x = Q Exp -> Q (TExp Int16)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int16 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int16
x)
  lift :: Int16 -> Q Exp
lift Int16
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int16 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int16
x)))

instance Lift Int32 where
  liftTyped :: Int32 -> Q (TExp Int32)
liftTyped Int32
x = Q Exp -> Q (TExp Int32)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int32 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int32
x)
  lift :: Int32 -> Q Exp
lift Int32
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int32 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
x)))

instance Lift Int64 where
  liftTyped :: Int64 -> Q (TExp Int64)
liftTyped Int64
x = Q Exp -> Q (TExp Int64)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Int64 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Int64
x)
  lift :: Int64 -> Q Exp
lift Int64
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Int64 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int64
x)))

-- | @since 2.16.0.0
instance Lift Word# where
  liftTyped :: Word# -> Q (TExp Word#)
liftTyped Word#
x = Q Exp -> Q (TExp Word#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word#
x)
  lift :: Word# -> Q Exp
lift Word#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
WordPrimL (Word -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word# -> Word
W# Word#
x))))

instance Lift Word where
  liftTyped :: Word -> Q (TExp Word)
liftTyped Word
x = Q Exp -> Q (TExp Word)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word
x)
  lift :: Word -> Q Exp
lift Word
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word
x)))

instance Lift Word8 where
  liftTyped :: Word8 -> Q (TExp Word8)
liftTyped Word8
x = Q Exp -> Q (TExp Word8)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word8 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word8
x)
  lift :: Word8 -> Q Exp
lift Word8
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word8 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
x)))

instance Lift Word16 where
  liftTyped :: Word16 -> Q (TExp Word16)
liftTyped Word16
x = Q Exp -> Q (TExp Word16)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word16 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word16
x)
  lift :: Word16 -> Q Exp
lift Word16
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word16 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
x)))

instance Lift Word32 where
  liftTyped :: Word32 -> Q (TExp Word32)
liftTyped Word32
x = Q Exp -> Q (TExp Word32)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word32 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word32
x)
  lift :: Word32 -> Q Exp
lift Word32
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word32 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
x)))

instance Lift Word64 where
  liftTyped :: Word64 -> Q (TExp Word64)
liftTyped Word64
x = Q Exp -> Q (TExp Word64)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Word64 -> Q Exp
forall t. Lift t => t -> Q Exp
lift Word64
x)
  lift :: Word64 -> Q Exp
lift Word64
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Word64 -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
x)))

instance Lift Natural where
  liftTyped :: Natural -> Q (TExp Natural)
liftTyped Natural
x = Q Exp -> Q (TExp Natural)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Natural -> Q Exp
forall t. Lift t => t -> Q Exp
lift Natural
x)
  lift :: Natural -> Q Exp
lift Natural
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Uniq -> Lit
IntegerL (Natural -> Uniq
forall a b. (Integral a, Num b) => a -> b
fromIntegral Natural
x)))

instance Integral a => Lift (Ratio a) where
  liftTyped :: Ratio a -> Q (TExp (Ratio a))
liftTyped Ratio a
x = Q Exp -> Q (TExp (Ratio a))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Ratio a -> Q Exp
forall t. Lift t => t -> Q Exp
lift Ratio a
x)
  lift :: Ratio a -> Q Exp
lift Ratio a
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
RationalL (Ratio a -> Rational
forall a. Real a => a -> Rational
toRational Ratio a
x)))

instance Lift Float where
  liftTyped :: Float -> Q (TExp Float)
liftTyped Float
x = Q Exp -> Q (TExp Float)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Float -> Q Exp
forall t. Lift t => t -> Q Exp
lift Float
x)
  lift :: Float -> Q Exp
lift Float
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
RationalL (Float -> Rational
forall a. Real a => a -> Rational
toRational Float
x)))

-- | @since 2.16.0.0
instance Lift Float# where
  liftTyped :: Float# -> Q (TExp Float#)
liftTyped Float#
x = Q Exp -> Q (TExp Float#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Float# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Float#
x)
  lift :: Float# -> Q Exp
lift Float#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
FloatPrimL (Float -> Rational
forall a. Real a => a -> Rational
toRational (Float# -> Float
F# Float#
x))))

instance Lift Double where
  liftTyped :: Double -> Q (TExp Double)
liftTyped Double
x = Q Exp -> Q (TExp Double)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Double -> Q Exp
forall t. Lift t => t -> Q Exp
lift Double
x)
  lift :: Double -> Q Exp
lift Double
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
RationalL (Double -> Rational
forall a. Real a => a -> Rational
toRational Double
x)))

-- | @since 2.16.0.0
instance Lift Double# where
  liftTyped :: Double# -> Q (TExp Double#)
liftTyped Double#
x = Q Exp -> Q (TExp Double#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Double# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Double#
x)
  lift :: Double# -> Q Exp
lift Double#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Rational -> Lit
DoublePrimL (Double -> Rational
forall a. Real a => a -> Rational
toRational (Double# -> Double
D# Double#
x))))

instance Lift Char where
  liftTyped :: Char -> Q (TExp Char)
liftTyped Char
x = Q Exp -> Q (TExp Char)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Char -> Q Exp
forall t. Lift t => t -> Q Exp
lift Char
x)
  lift :: Char -> Q Exp
lift Char
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Char -> Lit
CharL Char
x))

-- | @since 2.16.0.0
instance Lift Char# where
  liftTyped :: Char# -> Q (TExp Char#)
liftTyped Char#
x = Q Exp -> Q (TExp Char#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Char# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Char#
x)
  lift :: Char# -> Q Exp
lift Char#
x = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (Char -> Lit
CharPrimL (Char# -> Char
C# Char#
x)))

instance Lift Bool where
  liftTyped :: Bool -> Q (TExp Bool)
liftTyped Bool
x = Q Exp -> Q (TExp Bool)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Bool -> Q Exp
forall t. Lift t => t -> Q Exp
lift Bool
x)

  lift :: Bool -> Q Exp
lift Bool
True  = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE Name
trueName)
  lift Bool
False = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE Name
falseName)

-- | Produces an 'Addr#' literal from the NUL-terminated C-string starting at
-- the given memory address.
--
-- @since 2.16.0.0
instance Lift Addr# where
  liftTyped :: Addr# -> Q (TExp Addr#)
liftTyped Addr#
x = Q Exp -> Q (TExp Addr#)
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Addr# -> Q Exp
forall t. Lift t => t -> Q Exp
lift Addr#
x)
  lift :: Addr# -> Q Exp
lift Addr#
x
    = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE ([Word8] -> Lit
StringPrimL ((Char -> Word8) -> String -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
map (Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord) (Addr# -> String
unpackCString# Addr#
x))))

instance Lift a => Lift (Maybe a) where
  liftTyped :: Maybe a -> Q (TExp (Maybe a))
liftTyped Maybe a
x = Q Exp -> Q (TExp (Maybe a))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Maybe a -> Q Exp
forall t. Lift t => t -> Q Exp
lift Maybe a
x)

  lift :: Maybe a -> Q Exp
lift Maybe a
Nothing  = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE Name
nothingName)
  lift (Just a
x) = (Exp -> Exp) -> Q Exp -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Name -> Exp
ConE Name
justName Exp -> Exp -> Exp
`AppE`) (a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
x)

instance (Lift a, Lift b) => Lift (Either a b) where
  liftTyped :: Either a b -> Q (TExp (Either a b))
liftTyped Either a b
x = Q Exp -> Q (TExp (Either a b))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (Either a b -> Q Exp
forall t. Lift t => t -> Q Exp
lift Either a b
x)

  lift :: Either a b -> Q Exp
lift (Left a
x)  = (Exp -> Exp) -> Q Exp -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Name -> Exp
ConE Name
leftName  Exp -> Exp -> Exp
`AppE`) (a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
x)
  lift (Right b
y) = (Exp -> Exp) -> Q Exp -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (Name -> Exp
ConE Name
rightName Exp -> Exp -> Exp
`AppE`) (b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y)

instance Lift a => Lift [a] where
  liftTyped :: [a] -> Q (TExp [a])
liftTyped [a]
x = Q Exp -> Q (TExp [a])
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ([a] -> Q Exp
forall t. Lift t => t -> Q Exp
lift [a]
x)
  lift :: [a] -> Q Exp
lift [a]
xs = do { [Exp]
xs' <- (a -> Q Exp) -> [a] -> Q [Exp]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM a -> Q Exp
forall t. Lift t => t -> Q Exp
lift [a]
xs; Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return ([Exp] -> Exp
ListE [Exp]
xs') }

liftString :: String -> Q Exp
-- Used in TcExpr to short-circuit the lifting for strings
liftString :: String -> Q Exp
liftString String
s = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE (String -> Lit
StringL String
s))

-- | @since 2.15.0.0
instance Lift a => Lift (NonEmpty a) where
  liftTyped :: NonEmpty a -> Q (TExp (NonEmpty a))
liftTyped NonEmpty a
x = Q Exp -> Q (TExp (NonEmpty a))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (NonEmpty a -> Q Exp
forall t. Lift t => t -> Q Exp
lift NonEmpty a
x)

  lift :: NonEmpty a -> Q Exp
lift (a
x :| [a]
xs) = do
    Exp
x' <- a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
x
    Exp
xs' <- [a] -> Q Exp
forall t. Lift t => t -> Q Exp
lift [a]
xs
    Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Exp -> Exp -> Maybe Exp -> Exp
InfixE (Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
x') (Name -> Exp
ConE Name
nonemptyName) (Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
xs'))

-- | @since 2.15.0.0
instance Lift Void where
  liftTyped :: Void -> Q (TExp Void)
liftTyped = TExp Void -> Q (TExp Void)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (TExp Void -> Q (TExp Void))
-> (Void -> TExp Void) -> Void -> Q (TExp Void)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Void -> TExp Void
forall a. Void -> a
absurd
  lift :: Void -> Q Exp
lift = Exp -> Q Exp
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Exp -> Q Exp) -> (Void -> Exp) -> Void -> Q Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Void -> Exp
forall a. Void -> a
absurd

instance Lift () where
  liftTyped :: () -> Q (TExp ())
liftTyped ()
x = Q Exp -> Q (TExp ())
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce (() -> Q Exp
forall t. Lift t => t -> Q Exp
lift ()
x)
  lift :: () -> Q Exp
lift () = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE (Int -> Name
tupleDataName Int
0))

instance (Lift a, Lift b) => Lift (a, b) where
  liftTyped :: (a, b) -> Q (TExp (a, b))
liftTyped (a, b)
x = Q Exp -> Q (TExp (a, b))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b)
x)
  lift :: (a, b) -> Q Exp
lift (a
a, b
b)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b]

instance (Lift a, Lift b, Lift c) => Lift (a, b, c) where
  liftTyped :: (a, b, c) -> Q (TExp (a, b, c))
liftTyped (a, b, c)
x = Q Exp -> Q (TExp (a, b, c))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c)
x)
  lift :: (a, b, c) -> Q Exp
lift (a
a, b
b, c
c)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c]

instance (Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d) where
  liftTyped :: (a, b, c, d) -> Q (TExp (a, b, c, d))
liftTyped (a, b, c, d)
x = Q Exp -> Q (TExp (a, b, c, d))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c, d) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c, d)
x)
  lift :: (a, b, c, d) -> Q Exp
lift (a
a, b
b, c
c, d
d)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d]

instance (Lift a, Lift b, Lift c, Lift d, Lift e)
      => Lift (a, b, c, d, e) where
  liftTyped :: (a, b, c, d, e) -> Q (TExp (a, b, c, d, e))
liftTyped (a, b, c, d, e)
x = Q Exp -> Q (TExp (a, b, c, d, e))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c, d, e) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c, d, e)
x)
  lift :: (a, b, c, d, e) -> Q Exp
lift (a
a, b
b, c
c, d
d, e
e)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b
                                              , c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e ]

instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
      => Lift (a, b, c, d, e, f) where
  liftTyped :: (a, b, c, d, e, f) -> Q (TExp (a, b, c, d, e, f))
liftTyped (a, b, c, d, e, f)
x = Q Exp -> Q (TExp (a, b, c, d, e, f))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c, d, e, f) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c, d, e, f)
x)
  lift :: (a, b, c, d, e, f) -> Q Exp
lift (a
a, b
b, c
c, d
d, e
e, f
f)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c
                                              , d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e, f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
f ]

instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
      => Lift (a, b, c, d, e, f, g) where
  liftTyped :: (a, b, c, d, e, f, g) -> Q (TExp (a, b, c, d, e, f, g))
liftTyped (a, b, c, d, e, f, g)
x = Q Exp -> Q (TExp (a, b, c, d, e, f, g))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((a, b, c, d, e, f, g) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (a, b, c, d, e, f, g)
x)
  lift :: (a, b, c, d, e, f, g) -> Q Exp
lift (a
a, b
b, c
c, d
d, e
e, f
f, g
g)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
TupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c
                                              , d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e, f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
f, g -> Q Exp
forall t. Lift t => t -> Q Exp
lift g
g ]

-- | @since 2.16.0.0
instance Lift (# #) where
  liftTyped :: (# #) -> Q (TExp (# #))
liftTyped (# #)
x = Q Exp -> Q (TExp (# #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# #)
x)
  lift :: (# #) -> Q Exp
lift (# #) = Exp -> Q Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE (Int -> Name
unboxedTupleTypeName Int
0))

-- | @since 2.16.0.0
instance (Lift a) => Lift (# a #) where
  liftTyped :: (# a #) -> Q (TExp (# a #))
liftTyped (# a #)
x = Q Exp -> Q (TExp (# a #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a #)
x)
  lift :: (# a #) -> Q Exp
lift (# a
a #)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a]

-- | @since 2.16.0.0
instance (Lift a, Lift b) => Lift (# a, b #) where
  liftTyped :: (# a, b #) -> Q (TExp (# a, b #))
liftTyped (# a, b #)
x = Q Exp -> Q (TExp (# a, b #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b #)
x)
  lift :: (# a, b #) -> Q Exp
lift (# a
a, b
b #)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b]

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c)
      => Lift (# a, b, c #) where
  liftTyped :: (# a, b, c #) -> Q (TExp (# a, b, c #))
liftTyped (# a, b, c #)
x = Q Exp -> Q (TExp (# a, b, c #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c #)
x)
  lift :: (# a, b, c #) -> Q Exp
lift (# a
a, b
b, c
c #)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c]

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c, Lift d)
      => Lift (# a, b, c, d #) where
  liftTyped :: (# a, b, c, d #) -> Q (TExp (# a, b, c, d #))
liftTyped (# a, b, c, d #)
x = Q Exp -> Q (TExp (# a, b, c, d #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c, d #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c, d #)
x)
  lift :: (# a, b, c, d #) -> Q Exp
lift (# a
a, b
b, c
c, d
d #)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b
                                                     , c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d ]

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c, Lift d, Lift e)
      => Lift (# a, b, c, d, e #) where
  liftTyped :: (# a, b, c, d, e #) -> Q (TExp (# a, b, c, d, e #))
liftTyped (# a, b, c, d, e #)
x = Q Exp -> Q (TExp (# a, b, c, d, e #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c, d, e #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c, d, e #)
x)
  lift :: (# a, b, c, d, e #) -> Q Exp
lift (# a
a, b
b, c
c, d
d, e
e #)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b
                                                     , c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c, d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e ]

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
      => Lift (# a, b, c, d, e, f #) where
  liftTyped :: (# a, b, c, d, e, f #) -> Q (TExp (# a, b, c, d, e, f #))
liftTyped (# a, b, c, d, e, f #)
x = Q Exp -> Q (TExp (# a, b, c, d, e, f #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c, d, e, f #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c, d, e, f #)
x)
  lift :: (# a, b, c, d, e, f #) -> Q Exp
lift (# a
a, b
b, c
c, d
d, e
e, f
f #)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c
                                                     , d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e, f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
f ]

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
      => Lift (# a, b, c, d, e, f, g #) where
  liftTyped :: (# a, b, c, d, e, f, g #) -> Q (TExp (# a, b, c, d, e, f, g #))
liftTyped (# a, b, c, d, e, f, g #)
x = Q Exp -> Q (TExp (# a, b, c, d, e, f, g #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a, b, c, d, e, f, g #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a, b, c, d, e, f, g #)
x)
  lift :: (# a, b, c, d, e, f, g #) -> Q Exp
lift (# a
a, b
b, c
c, d
d, e
e, f
f, g
g #)
    = ([Maybe Exp] -> Exp) -> Q [Maybe Exp] -> Q Exp
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM [Maybe Exp] -> Exp
UnboxedTupE (Q [Maybe Exp] -> Q Exp) -> Q [Maybe Exp] -> Q Exp
forall a b. (a -> b) -> a -> b
$ [Q (Maybe Exp)] -> Q [Maybe Exp]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ([Q (Maybe Exp)] -> Q [Maybe Exp])
-> [Q (Maybe Exp)] -> Q [Maybe Exp]
forall a b. (a -> b) -> a -> b
$ (Q Exp -> Q (Maybe Exp)) -> [Q Exp] -> [Q (Maybe Exp)]
forall a b. (a -> b) -> [a] -> [b]
map ((Exp -> Maybe Exp) -> Q Exp -> Q (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Exp -> Maybe Exp
forall a. a -> Maybe a
Just) [ a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
a, b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
b, c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
c
                                                     , d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
d, e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
e, f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
f
                                                     , g -> Q Exp
forall t. Lift t => t -> Q Exp
lift g
g ]

-- | @since 2.16.0.0
instance (Lift a, Lift b) => Lift (# a | b #) where
  liftTyped :: (# a | b #) -> Q (TExp (# a | b #))
liftTyped (# a | b #)
x = Q Exp -> Q (TExp (# a | b #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b #)
x)
  lift :: (# a | b #) -> Q Exp
lift (# a | b #)
x
    = case (# a | b #)
x of
        (# a
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2
        (# | b
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c)
      => Lift (# a | b | c #) where
  liftTyped :: (# a | b | c #) -> Q (TExp (# a | b | c #))
liftTyped (# a | b | c #)
x = Q Exp -> Q (TExp (# a | b | c #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c #)
x)
  lift :: (# a | b | c #) -> Q Exp
lift (# a | b | c #)
x
    = case (# a | b | c #)
x of
        (# a
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3
        (# | b
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3
        (# | | c
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c, Lift d)
      => Lift (# a | b | c | d #) where
  liftTyped :: (# a | b | c | d #) -> Q (TExp (# a | b | c | d #))
liftTyped (# a | b | c | d #)
x = Q Exp -> Q (TExp (# a | b | c | d #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c | d #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c | d #)
x)
  lift :: (# a | b | c | d #) -> Q Exp
lift (# a | b | c | d #)
x
    = case (# a | b | c | d #)
x of
        (# a
y | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4
        (# | b
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4
        (# | | c
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4
        (# | | | d
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c, Lift d, Lift e)
      => Lift (# a | b | c | d | e #) where
  liftTyped :: (# a | b | c | d | e #) -> Q (TExp (# a | b | c | d | e #))
liftTyped (# a | b | c | d | e #)
x = Q Exp -> Q (TExp (# a | b | c | d | e #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c | d | e #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c | d | e #)
x)
  lift :: (# a | b | c | d | e #) -> Q Exp
lift (# a | b | c | d | e #)
x
    = case (# a | b | c | d | e #)
x of
        (# a
y | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5
        (# | b
y | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5
        (# | | c
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5
        (# | | | d
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5
        (# | | | | e
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f)
      => Lift (# a | b | c | d | e | f #) where
  liftTyped :: (# a | b | c | d | e | f #) -> Q (TExp (# a | b | c | d | e | f #))
liftTyped (# a | b | c | d | e | f #)
x = Q Exp -> Q (TExp (# a | b | c | d | e | f #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c | d | e | f #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c | d | e | f #)
x)
  lift :: (# a | b | c | d | e | f #) -> Q Exp
lift (# a | b | c | d | e | f #)
x
    = case (# a | b | c | d | e | f #)
x of
        (# a
y | | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
        (# | b
y | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
        (# | | c
y | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
        (# | | | d
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
        (# | | | | e
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6
        (# | | | | | f
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6

-- | @since 2.16.0.0
instance (Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g)
      => Lift (# a | b | c | d | e | f | g #) where
  liftTyped :: (# a | b | c | d | e | f | g #)
-> Q (TExp (# a | b | c | d | e | f | g #))
liftTyped (# a | b | c | d | e | f | g #)
x = Q Exp -> Q (TExp (# a | b | c | d | e | f | g #))
forall a. Q Exp -> Q (TExp a)
unsafeTExpCoerce ((# a | b | c | d | e | f | g #) -> Q Exp
forall t. Lift t => t -> Q Exp
lift (# a | b | c | d | e | f | g #)
x)
  lift :: (# a | b | c | d | e | f | g #) -> Q Exp
lift (# a | b | c | d | e | f | g #)
x
    = case (# a | b | c | d | e | f | g #)
x of
        (# a
y | | | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Q Exp
forall t. Lift t => t -> Q Exp
lift a
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
1 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
        (# | b
y | | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> Q Exp
forall t. Lift t => t -> Q Exp
lift b
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
2 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
        (# | | c
y | | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> c -> Q Exp
forall t. Lift t => t -> Q Exp
lift c
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
3 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
        (# | | | d
y | | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> d -> Q Exp
forall t. Lift t => t -> Q Exp
lift d
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
4 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
        (# | | | | e
y | | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> e -> Q Exp
forall t. Lift t => t -> Q Exp
lift e
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
5 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
        (# | | | | | f
y | #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f -> Q Exp
forall t. Lift t => t -> Q Exp
lift f
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
6 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7
        (# | | | | | | g
y #) -> Exp -> Int -> Int -> Exp
UnboxedSumE (Exp -> Int -> Int -> Exp) -> Q Exp -> Q (Int -> Int -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> g -> Q Exp
forall t. Lift t => t -> Q Exp
lift g
y Q (Int -> Int -> Exp) -> Q Int -> Q (Int -> Exp)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7 Q (Int -> Exp) -> Q Int -> Q Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Q Int
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
7

-- TH has a special form for literal strings,
-- which we should take advantage of.
-- NB: the lhs of the rule has no args, so that
--     the rule will apply to a 'lift' all on its own
--     which happens to be the way the type checker
--     creates it.
{-# RULES "TH:liftString" lift = \s -> return (LitE (StringL s)) #-}


trueName, falseName :: Name
trueName :: Name
trueName  = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"ghc-prim" String
"GHC.Types" String
"True"
falseName :: Name
falseName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"ghc-prim" String
"GHC.Types" String
"False"

nothingName, justName :: Name
nothingName :: Name
nothingName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"GHC.Maybe" String
"Nothing"
justName :: Name
justName    = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"GHC.Maybe" String
"Just"

leftName, rightName :: Name
leftName :: Name
leftName  = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"Data.Either" String
"Left"
rightName :: Name
rightName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"Data.Either" String
"Right"

nonemptyName :: Name
nonemptyName :: Name
nonemptyName = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName String
"base" String
"GHC.Base" String
":|"

-----------------------------------------------------
--
--              Generic Lift implementations
--
-----------------------------------------------------

-- | 'dataToQa' is an internal utility function for constructing generic
-- conversion functions from types with 'Data' instances to various
-- quasi-quoting representations.  See the source of 'dataToExpQ' and
-- 'dataToPatQ' for two example usages: @mkCon@, @mkLit@
-- and @appQ@ are overloadable to account for different syntax for
-- expressions and patterns; @antiQ@ allows you to override type-specific
-- cases, a common usage is just @const Nothing@, which results in
-- no overloading.
dataToQa  ::  forall a k q. Data a
          =>  (Name -> k)
          ->  (Lit -> Q q)
          ->  (k -> [Q q] -> Q q)
          ->  (forall b . Data b => b -> Maybe (Q q))
          ->  a
          ->  Q q
dataToQa :: (Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> a
-> Q q
dataToQa Name -> k
mkCon Lit -> Q q
mkLit k -> [Q q] -> Q q
appCon forall b. Data b => b -> Maybe (Q q)
antiQ a
t =
    case a -> Maybe (Q q)
forall b. Data b => b -> Maybe (Q q)
antiQ a
t of
      Maybe (Q q)
Nothing ->
          case Constr -> ConstrRep
constrRep Constr
constr of
            AlgConstr Int
_ ->
                k -> [Q q] -> Q q
appCon (Name -> k
mkCon Name
funOrConName) [Q q]
conArgs
              where
                funOrConName :: Name
                funOrConName :: Name
funOrConName =
                    case Constr -> String
showConstr Constr
constr of
                      String
"(:)"       -> OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
":")
                                          (NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
DataName
                                                (String -> PkgName
mkPkgName String
"ghc-prim")
                                                (String -> ModName
mkModName String
"GHC.Types"))
                      con :: String
con@String
"[]"    -> OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
con)
                                          (NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
DataName
                                                (String -> PkgName
mkPkgName String
"ghc-prim")
                                                (String -> ModName
mkModName String
"GHC.Types"))
                      con :: String
con@(Char
'(':String
_) -> OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
con)
                                          (NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
DataName
                                                (String -> PkgName
mkPkgName String
"ghc-prim")
                                                (String -> ModName
mkModName String
"GHC.Tuple"))

                      -- Tricky case: see Note [Data for non-algebraic types]
                      fun :: String
fun@(Char
x:String
_)   | Char -> Bool
startsVarSym Char
x Bool -> Bool -> Bool
|| Char -> Bool
startsVarId Char
x
                                  -> String -> String -> String -> Name
mkNameG_v String
tyconPkg String
tyconMod String
fun
                      String
con         -> String -> String -> String -> Name
mkNameG_d String
tyconPkg String
tyconMod String
con

                  where
                    tycon :: TyCon
                    tycon :: TyCon
tycon = (TypeRep -> TyCon
typeRepTyCon (TypeRep -> TyCon) -> (a -> TypeRep) -> a -> TyCon
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> TypeRep
forall a. Typeable a => a -> TypeRep
typeOf) a
t

                    tyconPkg, tyconMod :: String
                    tyconPkg :: String
tyconPkg = TyCon -> String
tyConPackage TyCon
tycon
                    tyconMod :: String
tyconMod = TyCon -> String
tyConModule  TyCon
tycon

                conArgs :: [Q q]
                conArgs :: [Q q]
conArgs = (forall d. Data d => d -> Q q) -> a -> [Q q]
forall a u. Data a => (forall d. Data d => d -> u) -> a -> [u]
gmapQ ((Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> d
-> Q q
forall a k q.
Data a =>
(Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> a
-> Q q
dataToQa Name -> k
mkCon Lit -> Q q
mkLit k -> [Q q] -> Q q
appCon forall b. Data b => b -> Maybe (Q q)
antiQ) a
t
            IntConstr Uniq
n ->
                Lit -> Q q
mkLit (Lit -> Q q) -> Lit -> Q q
forall a b. (a -> b) -> a -> b
$ Uniq -> Lit
IntegerL Uniq
n
            FloatConstr Rational
n ->
                Lit -> Q q
mkLit (Lit -> Q q) -> Lit -> Q q
forall a b. (a -> b) -> a -> b
$ Rational -> Lit
RationalL Rational
n
            CharConstr Char
c ->
                Lit -> Q q
mkLit (Lit -> Q q) -> Lit -> Q q
forall a b. (a -> b) -> a -> b
$ Char -> Lit
CharL Char
c
        where
          constr :: Constr
          constr :: Constr
constr = a -> Constr
forall a. Data a => a -> Constr
toConstr a
t

      Just Q q
y -> Q q
y


{- Note [Data for non-algebraic types]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Class Data was originally intended for algebraic data types.  But
it is possible to use it for abstract types too.  For example, in
package `text` we find

  instance Data Text where
    ...
    toConstr _ = packConstr

  packConstr :: Constr
  packConstr = mkConstr textDataType "pack" [] Prefix

Here `packConstr` isn't a real data constructor, it's an ordinary
function.  Two complications

* In such a case, we must take care to build the Name using
  mkNameG_v (for values), not mkNameG_d (for data constructors).
  See #10796.

* The pseudo-constructor is named only by its string, here "pack".
  But 'dataToQa' needs the TyCon of its defining module, and has
  to assume it's defined in the same module as the TyCon itself.
  But nothing enforces that; #12596 shows what goes wrong if
  "pack" is defined in a different module than the data type "Text".
  -}

-- | 'dataToExpQ' converts a value to a 'Q Exp' representation of the
-- same value, in the SYB style. It is generalized to take a function
-- override type-specific cases; see 'liftData' for a more commonly
-- used variant.
dataToExpQ  ::  Data a
            =>  (forall b . Data b => b -> Maybe (Q Exp))
            ->  a
            ->  Q Exp
dataToExpQ :: (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp
dataToExpQ = (Name -> Q Exp)
-> (Lit -> Q Exp)
-> (Q Exp -> [Q Exp] -> Q Exp)
-> (forall b. Data b => b -> Maybe (Q Exp))
-> a
-> Q Exp
forall a k q.
Data a =>
(Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> a
-> Q q
dataToQa Name -> Q Exp
forall (m :: * -> *). MonadFail m => Name -> m Exp
varOrConE Lit -> Q Exp
forall (m :: * -> *). Monad m => Lit -> m Exp
litE ((Q Exp -> Q Exp -> Q Exp) -> Q Exp -> [Q Exp] -> Q Exp
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl Q Exp -> Q Exp -> Q Exp
forall (m :: * -> *). Monad m => m Exp -> m Exp -> m Exp
appE)
    where
          -- Make sure that VarE is used if the Constr value relies on a
          -- function underneath the surface (instead of a constructor).
          -- See #10796.
          varOrConE :: Name -> m Exp
varOrConE Name
s =
            case Name -> Maybe NameSpace
nameSpace Name
s of
                 Just NameSpace
VarName  -> Exp -> m Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
VarE Name
s)
                 Just NameSpace
DataName -> Exp -> m Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> Exp
ConE Name
s)
                 Maybe NameSpace
_ -> String -> m Exp
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m Exp) -> String -> m Exp
forall a b. (a -> b) -> a -> b
$ String
"Can't construct an expression from name "
                          String -> String -> String
forall a. [a] -> [a] -> [a]
++ Name -> String
showName Name
s
          appE :: m Exp -> m Exp -> m Exp
appE m Exp
x m Exp
y = do { Exp
a <- m Exp
x; Exp
b <- m Exp
y; Exp -> m Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> Exp -> Exp
AppE Exp
a Exp
b)}
          litE :: Lit -> m Exp
litE Lit
c = Exp -> m Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Exp
LitE Lit
c)

-- | 'liftData' is a variant of 'lift' in the 'Lift' type class which
-- works for any type with a 'Data' instance.
liftData :: Data a => a -> Q Exp
liftData :: a -> Q Exp
liftData = (forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp
forall a.
Data a =>
(forall b. Data b => b -> Maybe (Q Exp)) -> a -> Q Exp
dataToExpQ (Maybe (Q Exp) -> b -> Maybe (Q Exp)
forall a b. a -> b -> a
const Maybe (Q Exp)
forall a. Maybe a
Nothing)

-- | 'dataToPatQ' converts a value to a 'Q Pat' representation of the same
-- value, in the SYB style. It takes a function to handle type-specific cases,
-- alternatively, pass @const Nothing@ to get default behavior.
dataToPatQ  ::  Data a
            =>  (forall b . Data b => b -> Maybe (Q Pat))
            ->  a
            ->  Q Pat
dataToPatQ :: (forall b. Data b => b -> Maybe (Q Pat)) -> a -> Q Pat
dataToPatQ = (Name -> Name)
-> (Lit -> Q Pat)
-> (Name -> [Q Pat] -> Q Pat)
-> (forall b. Data b => b -> Maybe (Q Pat))
-> a
-> Q Pat
forall a k q.
Data a =>
(Name -> k)
-> (Lit -> Q q)
-> (k -> [Q q] -> Q q)
-> (forall b. Data b => b -> Maybe (Q q))
-> a
-> Q q
dataToQa Name -> Name
forall a. a -> a
id Lit -> Q Pat
forall (m :: * -> *). Monad m => Lit -> m Pat
litP Name -> [Q Pat] -> Q Pat
forall (m :: * -> *). MonadFail m => Name -> [m Pat] -> m Pat
conP
    where litP :: Lit -> m Pat
litP Lit
l = Pat -> m Pat
forall (m :: * -> *) a. Monad m => a -> m a
return (Lit -> Pat
LitP Lit
l)
          conP :: Name -> [m Pat] -> m Pat
conP Name
n [m Pat]
ps =
            case Name -> Maybe NameSpace
nameSpace Name
n of
                Just NameSpace
DataName -> do
                    [Pat]
ps' <- [m Pat] -> m [Pat]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [m Pat]
ps
                    Pat -> m Pat
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> [Pat] -> Pat
ConP Name
n [Pat]
ps')
                Maybe NameSpace
_ -> String -> m Pat
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m Pat) -> String -> m Pat
forall a b. (a -> b) -> a -> b
$ String
"Can't construct a pattern from name "
                         String -> String -> String
forall a. [a] -> [a] -> [a]
++ Name -> String
showName Name
n

-----------------------------------------------------
--              Names and uniques
-----------------------------------------------------

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

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

-- | Obtained from 'reifyModule' and 'Language.Haskell.TH.Lib.thisModule'.
data Module = Module PkgName ModName -- package qualified module name
 deriving (Int -> Module -> String -> String
[Module] -> String -> String
Module -> String
(Int -> Module -> String -> String)
-> (Module -> String)
-> ([Module] -> String -> String)
-> Show Module
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Module] -> String -> String
$cshowList :: [Module] -> String -> String
show :: Module -> String
$cshow :: Module -> String
showsPrec :: Int -> Module -> String -> String
$cshowsPrec :: Int -> Module -> String -> String
Show,Module -> Module -> Bool
(Module -> Module -> Bool)
-> (Module -> Module -> Bool) -> Eq Module
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Module -> Module -> Bool
$c/= :: Module -> Module -> Bool
== :: Module -> Module -> Bool
$c== :: Module -> Module -> Bool
Eq,Eq Module
Eq Module
-> (Module -> Module -> Ordering)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Bool)
-> (Module -> Module -> Module)
-> (Module -> Module -> Module)
-> Ord Module
Module -> Module -> Bool
Module -> Module -> Ordering
Module -> Module -> Module
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Module -> Module -> Module
$cmin :: Module -> Module -> Module
max :: Module -> Module -> Module
$cmax :: Module -> Module -> Module
>= :: Module -> Module -> Bool
$c>= :: Module -> Module -> Bool
> :: Module -> Module -> Bool
$c> :: Module -> Module -> Bool
<= :: Module -> Module -> Bool
$c<= :: Module -> Module -> Bool
< :: Module -> Module -> Bool
$c< :: Module -> Module -> Bool
compare :: Module -> Module -> Ordering
$ccompare :: Module -> Module -> Ordering
$cp1Ord :: Eq Module
Ord,Typeable Module
DataType
Constr
Typeable Module
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Module -> c Module)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Module)
-> (Module -> Constr)
-> (Module -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Module))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module))
-> ((forall b. Data b => b -> b) -> Module -> Module)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Module -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Module -> r)
-> (forall u. (forall d. Data d => d -> u) -> Module -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Module -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Module -> m Module)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Module -> m Module)
-> Data Module
Module -> DataType
Module -> Constr
(forall b. Data b => b -> b) -> Module -> Module
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
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) -> Module -> u
forall u. (forall d. Data d => d -> u) -> Module -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cModule :: Constr
$tModule :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapMp :: (forall d. Data d => d -> m d) -> Module -> m Module
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapM :: (forall d. Data d => d -> m d) -> Module -> m Module
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Module -> m Module
gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Module -> u
gmapQ :: (forall d. Data d => d -> u) -> Module -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Module -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r
gmapT :: (forall b. Data b => b -> b) -> Module -> Module
$cgmapT :: (forall b. Data b => b -> b) -> Module -> Module
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Module)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Module)
dataTypeOf :: Module -> DataType
$cdataTypeOf :: Module -> DataType
toConstr :: Module -> Constr
$ctoConstr :: Module -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Module
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Module -> c Module
$cp1Data :: Typeable Module
Data,(forall x. Module -> Rep Module x)
-> (forall x. Rep Module x -> Module) -> Generic Module
forall x. Rep Module x -> Module
forall x. Module -> Rep Module x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Module x -> Module
$cfrom :: forall x. Module -> Rep Module x
Generic)

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

mkModName :: String -> ModName
mkModName :: String -> ModName
mkModName String
s = String -> ModName
ModName String
s

modString :: ModName -> String
modString :: ModName -> String
modString (ModName String
m) = String
m


mkPkgName :: String -> PkgName
mkPkgName :: String -> PkgName
mkPkgName String
s = String -> PkgName
PkgName String
s

pkgString :: PkgName -> String
pkgString :: PkgName -> String
pkgString (PkgName String
m) = String
m


-----------------------------------------------------
--              OccName
-----------------------------------------------------

mkOccName :: String -> OccName
mkOccName :: String -> OccName
mkOccName String
s = String -> OccName
OccName String
s

occString :: OccName -> String
occString :: OccName -> String
occString (OccName String
occ) = String
occ


-----------------------------------------------------
--               Names
-----------------------------------------------------
--
-- For "global" names ('NameG') we need a totally unique name,
-- so we must include the name-space of the thing
--
-- For unique-numbered things ('NameU'), we've got a unique reference
-- anyway, so no need for name space
--
-- For dynamically bound thing ('NameS') we probably want them to
-- in a context-dependent way, so again we don't want the name
-- space.  For example:
--
-- > let v = mkName "T" in [| data $v = $v |]
--
-- Here we use the same Name for both type constructor and data constructor
--
--
-- NameL and NameG are bound *outside* the TH syntax tree
-- either globally (NameG) or locally (NameL). Ex:
--
-- > f x = $(h [| (map, x) |])
--
-- The 'map' will be a NameG, and 'x' wil be a NameL
--
-- These Names should never appear in a binding position in a TH syntax tree

{- $namecapture #namecapture#
Much of 'Name' API is concerned with the problem of /name capture/, which
can be seen in the following example.

> f expr = [| let x = 0 in $expr |]
> ...
> g x = $( f [| x |] )
> h y = $( f [| y |] )

A naive desugaring of this would yield:

> g x = let x = 0 in x
> h y = let x = 0 in y

All of a sudden, @g@ and @h@ have different meanings! In this case,
we say that the @x@ in the RHS of @g@ has been /captured/
by the binding of @x@ in @f@.

What we actually want is for the @x@ in @f@ to be distinct from the
@x@ in @g@, so we get the following desugaring:

> g x = let x' = 0 in x
> h y = let x' = 0 in y

which avoids name capture as desired.

In the general case, we say that a @Name@ can be captured if
the thing it refers to can be changed by adding new declarations.
-}

{- |
An abstract type representing names in the syntax tree.

'Name's can be constructed in several ways, which come with different
name-capture guarantees (see "Language.Haskell.TH.Syntax#namecapture" for
an explanation of name capture):

  * the built-in syntax @'f@ and @''T@ can be used to construct names,
    The expression @'f@ gives a @Name@ which refers to the value @f@
    currently in scope, and @''T@ gives a @Name@ which refers to the
    type @T@ currently in scope. These names can never be captured.

  * 'lookupValueName' and 'lookupTypeName' are similar to @'f@ and
     @''T@ respectively, but the @Name@s are looked up at the point
     where the current splice is being run. These names can never be
     captured.

  * 'newName' monadically generates a new name, which can never
     be captured.

  * 'mkName' generates a capturable name.

Names constructed using @newName@ and @mkName@ may be used in bindings
(such as @let x = ...@ or @\x -> ...@), but names constructed using
@lookupValueName@, @lookupTypeName@, @'f@, @''T@ may not.
-}
data Name = Name OccName NameFlavour deriving (Typeable Name
DataType
Constr
Typeable Name
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name -> c Name)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Name)
-> (Name -> Constr)
-> (Name -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Name))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name))
-> ((forall b. Data b => b -> b) -> Name -> Name)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall u. (forall d. Data d => d -> u) -> Name -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Name -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> Data Name
Name -> DataType
Name -> Constr
(forall b. Data b => b -> b) -> Name -> Name
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
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) -> Name -> u
forall u. (forall d. Data d => d -> u) -> Name -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cName :: Constr
$tName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cp1Data :: Typeable Name
Data, Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq, (forall x. Name -> Rep Name x)
-> (forall x. Rep Name x -> Name) -> Generic Name
forall x. Rep Name x -> Name
forall x. Name -> Rep Name x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Name x -> Name
$cfrom :: forall x. Name -> Rep Name x
Generic)

instance Ord Name where
    -- check if unique is different before looking at strings
  (Name OccName
o1 NameFlavour
f1) compare :: Name -> Name -> Ordering
`compare` (Name OccName
o2 NameFlavour
f2) = (NameFlavour
f1 NameFlavour -> NameFlavour -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` NameFlavour
f2)   Ordering -> Ordering -> Ordering
`thenCmp`
                                        (OccName
o1 OccName -> OccName -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` OccName
o2)

data NameFlavour
  = NameS           -- ^ An unqualified name; dynamically bound
  | NameQ ModName   -- ^ A qualified name; dynamically bound
  | NameU !Uniq     -- ^ A unique local name
  | NameL !Uniq     -- ^ Local name bound outside of the TH AST
  | NameG NameSpace PkgName ModName -- ^ Global name bound outside of the TH AST:
                -- An original name (occurrences only, not binders)
                -- Need the namespace too to be sure which
                -- thing we are naming
  deriving ( Typeable NameFlavour
DataType
Constr
Typeable NameFlavour
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameFlavour -> c NameFlavour)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameFlavour)
-> (NameFlavour -> Constr)
-> (NameFlavour -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameFlavour))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NameFlavour))
-> ((forall b. Data b => b -> b) -> NameFlavour -> NameFlavour)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r)
-> (forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NameFlavour -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour)
-> Data NameFlavour
NameFlavour -> DataType
NameFlavour -> Constr
(forall b. Data b => b -> b) -> NameFlavour -> NameFlavour
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameFlavour
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) -> NameFlavour -> u
forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameFlavour
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameFlavour)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameFlavour)
$cNameG :: Constr
$cNameL :: Constr
$cNameU :: Constr
$cNameQ :: Constr
$cNameS :: Constr
$tNameFlavour :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
gmapMp :: (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
gmapM :: (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour
gmapQi :: Int -> (forall d. Data d => d -> u) -> NameFlavour -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameFlavour -> u
gmapQ :: (forall d. Data d => d -> u) -> NameFlavour -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameFlavour -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameFlavour -> r
gmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour
$cgmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameFlavour)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NameFlavour)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NameFlavour)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameFlavour)
dataTypeOf :: NameFlavour -> DataType
$cdataTypeOf :: NameFlavour -> DataType
toConstr :: NameFlavour -> Constr
$ctoConstr :: NameFlavour -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameFlavour
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameFlavour
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameFlavour -> c NameFlavour
$cp1Data :: Typeable NameFlavour
Data, NameFlavour -> NameFlavour -> Bool
(NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> Bool) -> Eq NameFlavour
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NameFlavour -> NameFlavour -> Bool
$c/= :: NameFlavour -> NameFlavour -> Bool
== :: NameFlavour -> NameFlavour -> Bool
$c== :: NameFlavour -> NameFlavour -> Bool
Eq, Eq NameFlavour
Eq NameFlavour
-> (NameFlavour -> NameFlavour -> Ordering)
-> (NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> Bool)
-> (NameFlavour -> NameFlavour -> NameFlavour)
-> (NameFlavour -> NameFlavour -> NameFlavour)
-> Ord NameFlavour
NameFlavour -> NameFlavour -> Bool
NameFlavour -> NameFlavour -> Ordering
NameFlavour -> NameFlavour -> NameFlavour
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NameFlavour -> NameFlavour -> NameFlavour
$cmin :: NameFlavour -> NameFlavour -> NameFlavour
max :: NameFlavour -> NameFlavour -> NameFlavour
$cmax :: NameFlavour -> NameFlavour -> NameFlavour
>= :: NameFlavour -> NameFlavour -> Bool
$c>= :: NameFlavour -> NameFlavour -> Bool
> :: NameFlavour -> NameFlavour -> Bool
$c> :: NameFlavour -> NameFlavour -> Bool
<= :: NameFlavour -> NameFlavour -> Bool
$c<= :: NameFlavour -> NameFlavour -> Bool
< :: NameFlavour -> NameFlavour -> Bool
$c< :: NameFlavour -> NameFlavour -> Bool
compare :: NameFlavour -> NameFlavour -> Ordering
$ccompare :: NameFlavour -> NameFlavour -> Ordering
$cp1Ord :: Eq NameFlavour
Ord, Int -> NameFlavour -> String -> String
[NameFlavour] -> String -> String
NameFlavour -> String
(Int -> NameFlavour -> String -> String)
-> (NameFlavour -> String)
-> ([NameFlavour] -> String -> String)
-> Show NameFlavour
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NameFlavour] -> String -> String
$cshowList :: [NameFlavour] -> String -> String
show :: NameFlavour -> String
$cshow :: NameFlavour -> String
showsPrec :: Int -> NameFlavour -> String -> String
$cshowsPrec :: Int -> NameFlavour -> String -> String
Show, (forall x. NameFlavour -> Rep NameFlavour x)
-> (forall x. Rep NameFlavour x -> NameFlavour)
-> Generic NameFlavour
forall x. Rep NameFlavour x -> NameFlavour
forall x. NameFlavour -> Rep NameFlavour x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameFlavour x -> NameFlavour
$cfrom :: forall x. NameFlavour -> Rep NameFlavour x
Generic )

data NameSpace = VarName        -- ^ Variables
               | DataName       -- ^ Data constructors
               | TcClsName      -- ^ Type constructors and classes; Haskell has them
                                -- in the same name space for now.
               deriving( NameSpace -> NameSpace -> Bool
(NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> Bool) -> Eq NameSpace
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NameSpace -> NameSpace -> Bool
$c/= :: NameSpace -> NameSpace -> Bool
== :: NameSpace -> NameSpace -> Bool
$c== :: NameSpace -> NameSpace -> Bool
Eq, Eq NameSpace
Eq NameSpace
-> (NameSpace -> NameSpace -> Ordering)
-> (NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> Bool)
-> (NameSpace -> NameSpace -> NameSpace)
-> (NameSpace -> NameSpace -> NameSpace)
-> Ord NameSpace
NameSpace -> NameSpace -> Bool
NameSpace -> NameSpace -> Ordering
NameSpace -> NameSpace -> NameSpace
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: NameSpace -> NameSpace -> NameSpace
$cmin :: NameSpace -> NameSpace -> NameSpace
max :: NameSpace -> NameSpace -> NameSpace
$cmax :: NameSpace -> NameSpace -> NameSpace
>= :: NameSpace -> NameSpace -> Bool
$c>= :: NameSpace -> NameSpace -> Bool
> :: NameSpace -> NameSpace -> Bool
$c> :: NameSpace -> NameSpace -> Bool
<= :: NameSpace -> NameSpace -> Bool
$c<= :: NameSpace -> NameSpace -> Bool
< :: NameSpace -> NameSpace -> Bool
$c< :: NameSpace -> NameSpace -> Bool
compare :: NameSpace -> NameSpace -> Ordering
$ccompare :: NameSpace -> NameSpace -> Ordering
$cp1Ord :: Eq NameSpace
Ord, Int -> NameSpace -> String -> String
[NameSpace] -> String -> String
NameSpace -> String
(Int -> NameSpace -> String -> String)
-> (NameSpace -> String)
-> ([NameSpace] -> String -> String)
-> Show NameSpace
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [NameSpace] -> String -> String
$cshowList :: [NameSpace] -> String -> String
show :: NameSpace -> String
$cshow :: NameSpace -> String
showsPrec :: Int -> NameSpace -> String -> String
$cshowsPrec :: Int -> NameSpace -> String -> String
Show, Typeable NameSpace
DataType
Constr
Typeable NameSpace
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NameSpace -> c NameSpace)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameSpace)
-> (NameSpace -> Constr)
-> (NameSpace -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameSpace))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace))
-> ((forall b. Data b => b -> b) -> NameSpace -> NameSpace)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameSpace -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameSpace -> r)
-> (forall u. (forall d. Data d => d -> u) -> NameSpace -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NameSpace -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace)
-> Data NameSpace
NameSpace -> DataType
NameSpace -> Constr
(forall b. Data b => b -> b) -> NameSpace -> NameSpace
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameSpace -> c NameSpace
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameSpace
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) -> NameSpace -> u
forall u. (forall d. Data d => d -> u) -> NameSpace -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameSpace
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameSpace -> c NameSpace
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameSpace)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)
$cTcClsName :: Constr
$cDataName :: Constr
$cVarName :: Constr
$tNameSpace :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
gmapMp :: (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
gmapM :: (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameSpace -> m NameSpace
gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameSpace -> u
gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameSpace -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameSpace -> r
gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace
$cgmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NameSpace)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameSpace)
dataTypeOf :: NameSpace -> DataType
$cdataTypeOf :: NameSpace -> DataType
toConstr :: NameSpace -> Constr
$ctoConstr :: NameSpace -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameSpace
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameSpace
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameSpace -> c NameSpace
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameSpace -> c NameSpace
$cp1Data :: Typeable NameSpace
Data, (forall x. NameSpace -> Rep NameSpace x)
-> (forall x. Rep NameSpace x -> NameSpace) -> Generic NameSpace
forall x. Rep NameSpace x -> NameSpace
forall x. NameSpace -> Rep NameSpace x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameSpace x -> NameSpace
$cfrom :: forall x. NameSpace -> Rep NameSpace x
Generic )

-- | @Uniq@ is used by GHC to distinguish names from each other.
type Uniq = Integer

-- | The name without its module prefix.
--
-- ==== __Examples__
--
-- >>> nameBase ''Data.Either.Either
-- "Either"
-- >>> nameBase (mkName "foo")
-- "foo"
-- >>> nameBase (mkName "Module.foo")
-- "foo"
nameBase :: Name -> String
nameBase :: Name -> String
nameBase (Name OccName
occ NameFlavour
_) = OccName -> String
occString OccName
occ

-- | Module prefix of a name, if it exists.
--
-- ==== __Examples__
--
-- >>> nameModule ''Data.Either.Either
-- Just "Data.Either"
-- >>> nameModule (mkName "foo")
-- Nothing
-- >>> nameModule (mkName "Module.foo")
-- Just "Module"
nameModule :: Name -> Maybe String
nameModule :: Name -> Maybe String
nameModule (Name OccName
_ (NameQ ModName
m))     = String -> Maybe String
forall a. a -> Maybe a
Just (ModName -> String
modString ModName
m)
nameModule (Name OccName
_ (NameG NameSpace
_ PkgName
_ ModName
m)) = String -> Maybe String
forall a. a -> Maybe a
Just (ModName -> String
modString ModName
m)
nameModule Name
_                      = Maybe String
forall a. Maybe a
Nothing

-- | A name's package, if it exists.
--
-- ==== __Examples__
--
-- >>> namePackage ''Data.Either.Either
-- Just "base"
-- >>> namePackage (mkName "foo")
-- Nothing
-- >>> namePackage (mkName "Module.foo")
-- Nothing
namePackage :: Name -> Maybe String
namePackage :: Name -> Maybe String
namePackage (Name OccName
_ (NameG NameSpace
_ PkgName
p ModName
_)) = String -> Maybe String
forall a. a -> Maybe a
Just (PkgName -> String
pkgString PkgName
p)
namePackage Name
_                      = Maybe String
forall a. Maybe a
Nothing

-- | Returns whether a name represents an occurrence of a top-level variable
-- ('VarName'), data constructor ('DataName'), type constructor, or type class
-- ('TcClsName'). If we can't be sure, it returns 'Nothing'.
--
-- ==== __Examples__
--
-- >>> nameSpace 'Prelude.id
-- Just VarName
-- >>> nameSpace (mkName "id")
-- Nothing -- only works for top-level variable names
-- >>> nameSpace 'Data.Maybe.Just
-- Just DataName
-- >>> nameSpace ''Data.Maybe.Maybe
-- Just TcClsName
-- >>> nameSpace ''Data.Ord.Ord
-- Just TcClsName
nameSpace :: Name -> Maybe NameSpace
nameSpace :: Name -> Maybe NameSpace
nameSpace (Name OccName
_ (NameG NameSpace
ns PkgName
_ ModName
_)) = NameSpace -> Maybe NameSpace
forall a. a -> Maybe a
Just NameSpace
ns
nameSpace Name
_                       = Maybe NameSpace
forall a. Maybe a
Nothing

{- |
Generate a capturable name. Occurrences of such names will be
resolved according to the Haskell scoping rules at the occurrence
site.

For example:

> f = [| pi + $(varE (mkName "pi")) |]
> ...
> g = let pi = 3 in $f

In this case, @g@ is desugared to

> g = Prelude.pi + 3

Note that @mkName@ may be used with qualified names:

> mkName "Prelude.pi"

See also 'Language.Haskell.TH.Lib.dyn' for a useful combinator. The above example could
be rewritten using 'Language.Haskell.TH.Lib.dyn' as

> f = [| pi + $(dyn "pi") |]
-}
mkName :: String -> Name
-- The string can have a '.', thus "Foo.baz",
-- giving a dynamically-bound qualified name,
-- in which case we want to generate a NameQ
--
-- Parse the string to see if it has a "." in it
-- so we know whether to generate a qualified or unqualified name
-- It's a bit tricky because we need to parse
--
-- > Foo.Baz.x   as    Qual Foo.Baz x
--
-- So we parse it from back to front
mkName :: String -> Name
mkName String
str
  = String -> String -> Name
split [] (String -> String
forall a. [a] -> [a]
reverse String
str)
  where
    split :: String -> String -> Name
split String
occ []        = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
occ) NameFlavour
NameS
    split String
occ (Char
'.':String
rev) | Bool -> Bool
not (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
occ)
                        , String -> Bool
is_rev_mod_name String
rev
                        = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
occ) (ModName -> NameFlavour
NameQ (String -> ModName
mkModName (String -> String
forall a. [a] -> [a]
reverse String
rev)))
        -- The 'not (null occ)' guard ensures that
        --      mkName "&." = Name "&." NameS
        -- The 'is_rev_mod' guards ensure that
        --      mkName ".&" = Name ".&" NameS
        --      mkName "^.." = Name "^.." NameS      -- #8633
        --      mkName "Data.Bits..&" = Name ".&" (NameQ "Data.Bits")
        -- This rather bizarre case actually happened; (.&.) is in Data.Bits
    split String
occ (Char
c:String
rev)   = String -> String -> Name
split (Char
cChar -> String -> String
forall a. a -> [a] -> [a]
:String
occ) String
rev

    -- Recognises a reversed module name xA.yB.C,
    -- with at least one component,
    -- and each component looks like a module name
    --   (i.e. non-empty, starts with capital, all alpha)
    is_rev_mod_name :: String -> Bool
is_rev_mod_name String
rev_mod_str
      | (String
compt, String
rest) <- (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'.') String
rev_mod_str
      , Bool -> Bool
not (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
compt), Char -> Bool
isUpper (String -> Char
forall a. [a] -> a
last String
compt), (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
is_mod_char String
compt
      = case String
rest of
          []             -> Bool
True
          (Char
_dot : String
rest') -> String -> Bool
is_rev_mod_name String
rest'
      | Bool
otherwise
      = Bool
False

    is_mod_char :: Char -> Bool
is_mod_char Char
c = Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\''

-- | Only used internally
mkNameU :: String -> Uniq -> Name
mkNameU :: String -> Uniq -> Name
mkNameU String
s Uniq
u = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
s) (Uniq -> NameFlavour
NameU Uniq
u)

-- | Only used internally
mkNameL :: String -> Uniq -> Name
mkNameL :: String -> Uniq -> Name
mkNameL String
s Uniq
u = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
s) (Uniq -> NameFlavour
NameL Uniq
u)

-- | Used for 'x etc, but not available to the programmer
mkNameG :: NameSpace -> String -> String -> String -> Name
mkNameG :: NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
ns String
pkg String
modu String
occ
  = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
occ) (NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
ns (String -> PkgName
mkPkgName String
pkg) (String -> ModName
mkModName String
modu))

mkNameS :: String -> Name
mkNameS :: String -> Name
mkNameS String
n = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
n) NameFlavour
NameS

mkNameG_v, mkNameG_tc, mkNameG_d :: String -> String -> String -> Name
mkNameG_v :: String -> String -> String -> Name
mkNameG_v  = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
VarName
mkNameG_tc :: String -> String -> String -> Name
mkNameG_tc = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
TcClsName
mkNameG_d :: String -> String -> String -> Name
mkNameG_d  = NameSpace -> String -> String -> String -> Name
mkNameG NameSpace
DataName

data NameIs = Alone | Applied | Infix

showName :: Name -> String
showName :: Name -> String
showName = NameIs -> Name -> String
showName' NameIs
Alone

showName' :: NameIs -> Name -> String
showName' :: NameIs -> Name -> String
showName' NameIs
ni Name
nm
 = case NameIs
ni of
       NameIs
Alone        -> String
nms
       NameIs
Applied
        | Bool
pnam      -> String
nms
        | Bool
otherwise -> String
"(" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
nms String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"
       NameIs
Infix
        | Bool
pnam      -> String
"`" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
nms String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"`"
        | Bool
otherwise -> String
nms
    where
        -- For now, we make the NameQ and NameG print the same, even though
        -- NameQ is a qualified name (so what it means depends on what the
        -- current scope is), and NameG is an original name (so its meaning
        -- should be independent of what's in scope.
        -- We may well want to distinguish them in the end.
        -- Ditto NameU and NameL
        nms :: String
nms = case Name
nm of
                    Name OccName
occ NameFlavour
NameS         -> OccName -> String
occString OccName
occ
                    Name OccName
occ (NameQ ModName
m)     -> ModName -> String
modString ModName
m String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"." String -> String -> String
forall a. [a] -> [a] -> [a]
++ OccName -> String
occString OccName
occ
                    Name OccName
occ (NameG NameSpace
_ PkgName
_ ModName
m) -> ModName -> String
modString ModName
m String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"." String -> String -> String
forall a. [a] -> [a] -> [a]
++ OccName -> String
occString OccName
occ
                    Name OccName
occ (NameU Uniq
u)     -> OccName -> String
occString OccName
occ String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"_" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Uniq -> String
forall a. Show a => a -> String
show Uniq
u
                    Name OccName
occ (NameL Uniq
u)     -> OccName -> String
occString OccName
occ String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"_" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Uniq -> String
forall a. Show a => a -> String
show Uniq
u

        pnam :: Bool
pnam = String -> Bool
classify String
nms

        -- True if we are function style, e.g. f, [], (,)
        -- False if we are operator style, e.g. +, :+
        classify :: String -> Bool
classify String
"" = Bool
False -- shouldn't happen; . operator is handled below
        classify (Char
x:String
xs) | Char -> Bool
isAlpha Char
x Bool -> Bool -> Bool
|| (Char
x Char -> String -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
"_[]()") =
                            case (Char -> Bool) -> String -> String
forall a. (a -> Bool) -> [a] -> [a]
dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/=Char
'.') String
xs of
                                  (Char
_:String
xs') -> String -> Bool
classify String
xs'
                                  []      -> Bool
True
                        | Bool
otherwise = Bool
False

instance Show Name where
  show :: Name -> String
show = Name -> String
showName

-- Tuple data and type constructors
-- | Tuple data constructor
tupleDataName :: Int -> Name
-- | Tuple type constructor
tupleTypeName :: Int -> Name

tupleDataName :: Int -> Name
tupleDataName Int
n = Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
DataName  Bool
True
tupleTypeName :: Int -> Name
tupleTypeName Int
n = Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
TcClsName Bool
True

-- Unboxed tuple data and type constructors
-- | Unboxed tuple data constructor
unboxedTupleDataName :: Int -> Name
-- | Unboxed tuple type constructor
unboxedTupleTypeName :: Int -> Name

unboxedTupleDataName :: Int -> Name
unboxedTupleDataName Int
n = Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
DataName  Bool
False
unboxedTupleTypeName :: Int -> Name
unboxedTupleTypeName Int
n = Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
TcClsName Bool
False

mk_tup_name :: Int -> NameSpace -> Bool -> Name
mk_tup_name :: Int -> NameSpace -> Bool -> Name
mk_tup_name Int
n NameSpace
space Bool
boxed
  = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
tup_occ) (NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
space (String -> PkgName
mkPkgName String
"ghc-prim") ModName
tup_mod)
  where
    withParens :: String -> String
withParens String
thing
      | Bool
boxed     = String
"("  String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
thing String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"
      | Bool
otherwise = String
"(#" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
thing String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"#)"
    tup_occ :: String
tup_occ | Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1    = if Bool
boxed then String
"Unit" else String
"Unit#"
            | Bool
otherwise = String -> String
withParens (Int -> Char -> String
forall a. Int -> a -> [a]
replicate Int
n_commas Char
',')
    n_commas :: Int
n_commas = Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
    tup_mod :: ModName
tup_mod  = String -> ModName
mkModName String
"GHC.Tuple"

-- Unboxed sum data and type constructors
-- | Unboxed sum data constructor
unboxedSumDataName :: SumAlt -> SumArity -> Name
-- | Unboxed sum type constructor
unboxedSumTypeName :: SumArity -> Name

unboxedSumDataName :: Int -> Int -> Name
unboxedSumDataName Int
alt Int
arity
  | Int
alt Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
arity
  = String -> Name
forall a. HasCallStack => String -> a
error (String -> Name) -> String -> Name
forall a b. (a -> b) -> a -> b
$ String
prefix String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Index out of bounds." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
debug_info

  | Int
alt Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0
  = String -> Name
forall a. HasCallStack => String -> a
error (String -> Name) -> String -> Name
forall a b. (a -> b) -> a -> b
$ String
prefix String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Alt must be > 0." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
debug_info

  | Int
arity Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2
  = String -> Name
forall a. HasCallStack => String -> a
error (String -> Name) -> String -> Name
forall a b. (a -> b) -> a -> b
$ String
prefix String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Arity must be >= 2." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
debug_info

  | Bool
otherwise
  = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
sum_occ)
         (NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
DataName (String -> PkgName
mkPkgName String
"ghc-prim") (String -> ModName
mkModName String
"GHC.Prim"))

  where
    prefix :: String
prefix     = String
"unboxedSumDataName: "
    debug_info :: String
debug_info = String
" (alt: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
alt String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
", arity: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
arity String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"

    -- Synced with the definition of mkSumDataConOcc in TysWiredIn
    sum_occ :: String
sum_occ = Char
'(' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'#' Char -> String -> String
forall a. a -> [a] -> [a]
: Int -> String
bars Int
nbars_before String -> String -> String
forall a. [a] -> [a] -> [a]
++ Char
'_' Char -> String -> String
forall a. a -> [a] -> [a]
: Int -> String
bars Int
nbars_after String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"#)"
    bars :: Int -> String
bars Int
i = Int -> Char -> String
forall a. Int -> a -> [a]
replicate Int
i Char
'|'
    nbars_before :: Int
nbars_before = Int
alt Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1
    nbars_after :: Int
nbars_after  = Int
arity Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
alt

unboxedSumTypeName :: Int -> Name
unboxedSumTypeName Int
arity
  | Int
arity Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
2
  = String -> Name
forall a. HasCallStack => String -> a
error (String -> Name) -> String -> Name
forall a b. (a -> b) -> a -> b
$ String
"unboxedSumTypeName: Arity must be >= 2."
         String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" (arity: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
arity String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
")"

  | Bool
otherwise
  = OccName -> NameFlavour -> Name
Name (String -> OccName
mkOccName String
sum_occ)
         (NameSpace -> PkgName -> ModName -> NameFlavour
NameG NameSpace
TcClsName (String -> PkgName
mkPkgName String
"ghc-prim") (String -> ModName
mkModName String
"GHC.Prim"))

  where
    -- Synced with the definition of mkSumTyConOcc in TysWiredIn
    sum_occ :: String
sum_occ = Char
'(' Char -> String -> String
forall a. a -> [a] -> [a]
: Char
'#' Char -> String -> String
forall a. a -> [a] -> [a]
: Int -> Char -> String
forall a. Int -> a -> [a]
replicate (Int
arity Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Char
'|' String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"#)"

-----------------------------------------------------
--              Locations
-----------------------------------------------------

data Loc
  = Loc { Loc -> String
loc_filename :: String
        , Loc -> String
loc_package  :: String
        , Loc -> String
loc_module   :: String
        , Loc -> CharPos
loc_start    :: CharPos
        , Loc -> CharPos
loc_end      :: CharPos }
   deriving( Int -> Loc -> String -> String
[Loc] -> String -> String
Loc -> String
(Int -> Loc -> String -> String)
-> (Loc -> String) -> ([Loc] -> String -> String) -> Show Loc
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Loc] -> String -> String
$cshowList :: [Loc] -> String -> String
show :: Loc -> String
$cshow :: Loc -> String
showsPrec :: Int -> Loc -> String -> String
$cshowsPrec :: Int -> Loc -> String -> String
Show, Loc -> Loc -> Bool
(Loc -> Loc -> Bool) -> (Loc -> Loc -> Bool) -> Eq Loc
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Loc -> Loc -> Bool
$c/= :: Loc -> Loc -> Bool
== :: Loc -> Loc -> Bool
$c== :: Loc -> Loc -> Bool
Eq, Eq Loc
Eq Loc
-> (Loc -> Loc -> Ordering)
-> (Loc -> Loc -> Bool)
-> (Loc -> Loc -> Bool)
-> (Loc -> Loc -> Bool)
-> (Loc -> Loc -> Bool)
-> (Loc -> Loc -> Loc)
-> (Loc -> Loc -> Loc)
-> Ord Loc
Loc -> Loc -> Bool
Loc -> Loc -> Ordering
Loc -> Loc -> Loc
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Loc -> Loc -> Loc
$cmin :: Loc -> Loc -> Loc
max :: Loc -> Loc -> Loc
$cmax :: Loc -> Loc -> Loc
>= :: Loc -> Loc -> Bool
$c>= :: Loc -> Loc -> Bool
> :: Loc -> Loc -> Bool
$c> :: Loc -> Loc -> Bool
<= :: Loc -> Loc -> Bool
$c<= :: Loc -> Loc -> Bool
< :: Loc -> Loc -> Bool
$c< :: Loc -> Loc -> Bool
compare :: Loc -> Loc -> Ordering
$ccompare :: Loc -> Loc -> Ordering
$cp1Ord :: Eq Loc
Ord, Typeable Loc
DataType
Constr
Typeable Loc
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Loc -> c Loc)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Loc)
-> (Loc -> Constr)
-> (Loc -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Loc))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc))
-> ((forall b. Data b => b -> b) -> Loc -> Loc)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r)
-> (forall u. (forall d. Data d => d -> u) -> Loc -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Loc -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Loc -> m Loc)
-> Data Loc
Loc -> DataType
Loc -> Constr
(forall b. Data b => b -> b) -> Loc -> Loc
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Loc -> c Loc
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Loc
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) -> Loc -> u
forall u. (forall d. Data d => d -> u) -> Loc -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Loc
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Loc -> c Loc
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Loc)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)
$cLoc :: Constr
$tLoc :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Loc -> m Loc
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
gmapMp :: (forall d. Data d => d -> m d) -> Loc -> m Loc
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
gmapM :: (forall d. Data d => d -> m d) -> Loc -> m Loc
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Loc -> m Loc
gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Loc -> u
gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Loc -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r
gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc
$cgmapT :: (forall b. Data b => b -> b) -> Loc -> Loc
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Loc)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Loc)
dataTypeOf :: Loc -> DataType
$cdataTypeOf :: Loc -> DataType
toConstr :: Loc -> Constr
$ctoConstr :: Loc -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Loc
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Loc
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Loc -> c Loc
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Loc -> c Loc
$cp1Data :: Typeable Loc
Data, (forall x. Loc -> Rep Loc x)
-> (forall x. Rep Loc x -> Loc) -> Generic Loc
forall x. Rep Loc x -> Loc
forall x. Loc -> Rep Loc x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Loc x -> Loc
$cfrom :: forall x. Loc -> Rep Loc x
Generic )

type CharPos = (Int, Int)       -- ^ Line and character position


-----------------------------------------------------
--
--      The Info returned by reification
--
-----------------------------------------------------

-- | Obtained from 'reify' in the 'Q' Monad.
data Info
  =
  -- | A class, with a list of its visible instances
  ClassI
      Dec
      [InstanceDec]

  -- | A class method
  | ClassOpI
       Name
       Type
       ParentName

  -- | A \"plain\" type constructor. \"Fancier\" type constructors are returned
  -- using 'PrimTyConI' or 'FamilyI' as appropriate. At present, this reified
  -- declaration will never have derived instances attached to it (if you wish
  -- to check for an instance, see 'reifyInstances').
  | TyConI
        Dec

  -- | A type or data family, with a list of its visible instances. A closed
  -- type family is returned with 0 instances.
  | FamilyI
        Dec
        [InstanceDec]

  -- | A \"primitive\" type constructor, which can't be expressed with a 'Dec'.
  -- Examples: @(->)@, @Int#@.
  | PrimTyConI
       Name
       Arity
       Unlifted

  -- | A data constructor
  | DataConI
       Name
       Type
       ParentName

  -- | A pattern synonym
  | PatSynI
       Name
       PatSynType

  {- |
  A \"value\" variable (as opposed to a type variable, see 'TyVarI').

  The @Maybe Dec@ field contains @Just@ the declaration which
  defined the variable - including the RHS of the declaration -
  or else @Nothing@, in the case where the RHS is unavailable to
  the compiler. At present, this value is /always/ @Nothing@:
  returning the RHS has not yet been implemented because of
  lack of interest.
  -}
  | VarI
       Name
       Type
       (Maybe Dec)

  {- |
  A type variable.

  The @Type@ field contains the type which underlies the variable.
  At present, this is always @'VarT' theName@, but future changes
  may permit refinement of this.
  -}
  | TyVarI      -- Scoped type variable
        Name
        Type    -- What it is bound to
  deriving( Int -> Info -> String -> String
[Info] -> String -> String
Info -> String
(Int -> Info -> String -> String)
-> (Info -> String) -> ([Info] -> String -> String) -> Show Info
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Info] -> String -> String
$cshowList :: [Info] -> String -> String
show :: Info -> String
$cshow :: Info -> String
showsPrec :: Int -> Info -> String -> String
$cshowsPrec :: Int -> Info -> String -> String
Show, Info -> Info -> Bool
(Info -> Info -> Bool) -> (Info -> Info -> Bool) -> Eq Info
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Info -> Info -> Bool
$c/= :: Info -> Info -> Bool
== :: Info -> Info -> Bool
$c== :: Info -> Info -> Bool
Eq, Eq Info
Eq Info
-> (Info -> Info -> Ordering)
-> (Info -> Info -> Bool)
-> (Info -> Info -> Bool)
-> (Info -> Info -> Bool)
-> (Info -> Info -> Bool)
-> (Info -> Info -> Info)
-> (Info -> Info -> Info)
-> Ord Info
Info -> Info -> Bool
Info -> Info -> Ordering
Info -> Info -> Info
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Info -> Info -> Info
$cmin :: Info -> Info -> Info
max :: Info -> Info -> Info
$cmax :: Info -> Info -> Info
>= :: Info -> Info -> Bool
$c>= :: Info -> Info -> Bool
> :: Info -> Info -> Bool
$c> :: Info -> Info -> Bool
<= :: Info -> Info -> Bool
$c<= :: Info -> Info -> Bool
< :: Info -> Info -> Bool
$c< :: Info -> Info -> Bool
compare :: Info -> Info -> Ordering
$ccompare :: Info -> Info -> Ordering
$cp1Ord :: Eq Info
Ord, Typeable Info
DataType
Constr
Typeable Info
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Info -> c Info)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Info)
-> (Info -> Constr)
-> (Info -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Info))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info))
-> ((forall b. Data b => b -> b) -> Info -> Info)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r)
-> (forall u. (forall d. Data d => d -> u) -> Info -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Info -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Info -> m Info)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Info -> m Info)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Info -> m Info)
-> Data Info
Info -> DataType
Info -> Constr
(forall b. Data b => b -> b) -> Info -> Info
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Info -> c Info
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Info
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) -> Info -> u
forall u. (forall d. Data d => d -> u) -> Info -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Info -> m Info
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Info -> m Info
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Info
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Info -> c Info
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Info)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)
$cTyVarI :: Constr
$cVarI :: Constr
$cPatSynI :: Constr
$cDataConI :: Constr
$cPrimTyConI :: Constr
$cFamilyI :: Constr
$cTyConI :: Constr
$cClassOpI :: Constr
$cClassI :: Constr
$tInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Info -> m Info
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Info -> m Info
gmapMp :: (forall d. Data d => d -> m d) -> Info -> m Info
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Info -> m Info
gmapM :: (forall d. Data d => d -> m d) -> Info -> m Info
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Info -> m Info
gmapQi :: Int -> (forall d. Data d => d -> u) -> Info -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Info -> u
gmapQ :: (forall d. Data d => d -> u) -> Info -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Info -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r
gmapT :: (forall b. Data b => b -> b) -> Info -> Info
$cgmapT :: (forall b. Data b => b -> b) -> Info -> Info
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Info)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Info)
dataTypeOf :: Info -> DataType
$cdataTypeOf :: Info -> DataType
toConstr :: Info -> Constr
$ctoConstr :: Info -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Info
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Info
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Info -> c Info
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Info -> c Info
$cp1Data :: Typeable Info
Data, (forall x. Info -> Rep Info x)
-> (forall x. Rep Info x -> Info) -> Generic Info
forall x. Rep Info x -> Info
forall x. Info -> Rep Info x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Info x -> Info
$cfrom :: forall x. Info -> Rep Info x
Generic )

-- | Obtained from 'reifyModule' in the 'Q' Monad.
data ModuleInfo =
  -- | Contains the import list of the module.
  ModuleInfo [Module]
  deriving( Int -> ModuleInfo -> String -> String
[ModuleInfo] -> String -> String
ModuleInfo -> String
(Int -> ModuleInfo -> String -> String)
-> (ModuleInfo -> String)
-> ([ModuleInfo] -> String -> String)
-> Show ModuleInfo
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [ModuleInfo] -> String -> String
$cshowList :: [ModuleInfo] -> String -> String
show :: ModuleInfo -> String
$cshow :: ModuleInfo -> String
showsPrec :: Int -> ModuleInfo -> String -> String
$cshowsPrec :: Int -> ModuleInfo -> String -> String
Show, ModuleInfo -> ModuleInfo -> Bool
(ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> Bool) -> Eq ModuleInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModuleInfo -> ModuleInfo -> Bool
$c/= :: ModuleInfo -> ModuleInfo -> Bool
== :: ModuleInfo -> ModuleInfo -> Bool
$c== :: ModuleInfo -> ModuleInfo -> Bool
Eq, Eq ModuleInfo
Eq ModuleInfo
-> (ModuleInfo -> ModuleInfo -> Ordering)
-> (ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> Bool)
-> (ModuleInfo -> ModuleInfo -> ModuleInfo)
-> (ModuleInfo -> ModuleInfo -> ModuleInfo)
-> Ord ModuleInfo
ModuleInfo -> ModuleInfo -> Bool
ModuleInfo -> ModuleInfo -> Ordering
ModuleInfo -> ModuleInfo -> ModuleInfo
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: ModuleInfo -> ModuleInfo -> ModuleInfo
$cmin :: ModuleInfo -> ModuleInfo -> ModuleInfo
max :: ModuleInfo -> ModuleInfo -> ModuleInfo
$cmax :: ModuleInfo -> ModuleInfo -> ModuleInfo
>= :: ModuleInfo -> ModuleInfo -> Bool
$c>= :: ModuleInfo -> ModuleInfo -> Bool
> :: ModuleInfo -> ModuleInfo -> Bool
$c> :: ModuleInfo -> ModuleInfo -> Bool
<= :: ModuleInfo -> ModuleInfo -> Bool
$c<= :: ModuleInfo -> ModuleInfo -> Bool
< :: ModuleInfo -> ModuleInfo -> Bool
$c< :: ModuleInfo -> ModuleInfo -> Bool
compare :: ModuleInfo -> ModuleInfo -> Ordering
$ccompare :: ModuleInfo -> ModuleInfo -> Ordering
$cp1Ord :: Eq ModuleInfo
Ord, Typeable ModuleInfo
DataType
Constr
Typeable ModuleInfo
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModuleInfo)
-> (ModuleInfo -> Constr)
-> (ModuleInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModuleInfo))
-> ((forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo)
-> Data ModuleInfo
ModuleInfo -> DataType
ModuleInfo -> Constr
(forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
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) -> ModuleInfo -> u
forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
$cModuleInfo :: Constr
$tModuleInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
gmapMp :: (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
gmapM :: (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ModuleInfo -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r
gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
$cgmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ModuleInfo)
dataTypeOf :: ModuleInfo -> DataType
$cdataTypeOf :: ModuleInfo -> DataType
toConstr :: ModuleInfo -> Constr
$ctoConstr :: ModuleInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModuleInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo
$cp1Data :: Typeable ModuleInfo
Data, (forall x. ModuleInfo -> Rep ModuleInfo x)
-> (forall x. Rep ModuleInfo x -> ModuleInfo) -> Generic ModuleInfo
forall x. Rep ModuleInfo x -> ModuleInfo
forall x. ModuleInfo -> Rep ModuleInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ModuleInfo x -> ModuleInfo
$cfrom :: forall x. ModuleInfo -> Rep ModuleInfo x
Generic )

{- |
In 'ClassOpI' and 'DataConI', name of the parent class or type
-}
type ParentName = Name

-- | In 'UnboxedSumE' and 'UnboxedSumP', the number associated with a
-- particular data constructor. 'SumAlt's are one-indexed and should never
-- exceed the value of its corresponding 'SumArity'. For example:
--
-- * @(\#_|\#)@ has 'SumAlt' 1 (out of a total 'SumArity' of 2)
--
-- * @(\#|_\#)@ has 'SumAlt' 2 (out of a total 'SumArity' of 2)
type SumAlt = Int

-- | In 'UnboxedSumE', 'UnboxedSumT', and 'UnboxedSumP', the total number of
-- 'SumAlt's. For example, @(\#|\#)@ has a 'SumArity' of 2.
type SumArity = Int

-- | In 'PrimTyConI', arity of the type constructor
type Arity = Int

-- | In 'PrimTyConI', is the type constructor unlifted?
type Unlifted = Bool

-- | 'InstanceDec' desribes a single instance of a class or type function.
-- It is just a 'Dec', but guaranteed to be one of the following:
--
--   * 'InstanceD' (with empty @['Dec']@)
--
--   * 'DataInstD' or 'NewtypeInstD' (with empty derived @['Name']@)
--
--   * 'TySynInstD'
type InstanceDec = Dec

data Fixity          = Fixity Int FixityDirection
    deriving( Fixity -> Fixity -> Bool
(Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Bool) -> Eq Fixity
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Fixity -> Fixity -> Bool
$c/= :: Fixity -> Fixity -> Bool
== :: Fixity -> Fixity -> Bool
$c== :: Fixity -> Fixity -> Bool
Eq, Eq Fixity
Eq Fixity
-> (Fixity -> Fixity -> Ordering)
-> (Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Bool)
-> (Fixity -> Fixity -> Fixity)
-> (Fixity -> Fixity -> Fixity)
-> Ord Fixity
Fixity -> Fixity -> Bool
Fixity -> Fixity -> Ordering
Fixity -> Fixity -> Fixity
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Fixity -> Fixity -> Fixity
$cmin :: Fixity -> Fixity -> Fixity
max :: Fixity -> Fixity -> Fixity
$cmax :: Fixity -> Fixity -> Fixity
>= :: Fixity -> Fixity -> Bool
$c>= :: Fixity -> Fixity -> Bool
> :: Fixity -> Fixity -> Bool
$c> :: Fixity -> Fixity -> Bool
<= :: Fixity -> Fixity -> Bool
$c<= :: Fixity -> Fixity -> Bool
< :: Fixity -> Fixity -> Bool
$c< :: Fixity -> Fixity -> Bool
compare :: Fixity -> Fixity -> Ordering
$ccompare :: Fixity -> Fixity -> Ordering
$cp1Ord :: Eq Fixity
Ord, Int -> Fixity -> String -> String
[Fixity] -> String -> String
Fixity -> String
(Int -> Fixity -> String -> String)
-> (Fixity -> String)
-> ([Fixity] -> String -> String)
-> Show Fixity
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Fixity] -> String -> String
$cshowList :: [Fixity] -> String -> String
show :: Fixity -> String
$cshow :: Fixity -> String
showsPrec :: Int -> Fixity -> String -> String
$cshowsPrec :: Int -> Fixity -> String -> String
Show, Typeable Fixity
DataType
Constr
Typeable Fixity
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Fixity -> c Fixity)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Fixity)
-> (Fixity -> Constr)
-> (Fixity -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Fixity))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity))
-> ((forall b. Data b => b -> b) -> Fixity -> Fixity)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Fixity -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Fixity -> r)
-> (forall u. (forall d. Data d => d -> u) -> Fixity -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Fixity -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fixity -> m Fixity)
-> Data Fixity
Fixity -> DataType
Fixity -> Constr
(forall b. Data b => b -> b) -> Fixity -> Fixity
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixity -> c Fixity
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fixity
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) -> Fixity -> u
forall u. (forall d. Data d => d -> u) -> Fixity -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fixity
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixity -> c Fixity
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fixity)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)
$cFixity :: Constr
$tFixity :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Fixity -> m Fixity
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
gmapMp :: (forall d. Data d => d -> m d) -> Fixity -> m Fixity
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
gmapM :: (forall d. Data d => d -> m d) -> Fixity -> m Fixity
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fixity -> m Fixity
gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Fixity -> u
gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Fixity -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r
gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity
$cgmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Fixity)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fixity)
dataTypeOf :: Fixity -> DataType
$cdataTypeOf :: Fixity -> DataType
toConstr :: Fixity -> Constr
$ctoConstr :: Fixity -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fixity
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fixity
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixity -> c Fixity
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fixity -> c Fixity
$cp1Data :: Typeable Fixity
Data, (forall x. Fixity -> Rep Fixity x)
-> (forall x. Rep Fixity x -> Fixity) -> Generic Fixity
forall x. Rep Fixity x -> Fixity
forall x. Fixity -> Rep Fixity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Fixity x -> Fixity
$cfrom :: forall x. Fixity -> Rep Fixity x
Generic )
data FixityDirection = InfixL | InfixR | InfixN
    deriving( FixityDirection -> FixityDirection -> Bool
(FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> Bool)
-> Eq FixityDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FixityDirection -> FixityDirection -> Bool
$c/= :: FixityDirection -> FixityDirection -> Bool
== :: FixityDirection -> FixityDirection -> Bool
$c== :: FixityDirection -> FixityDirection -> Bool
Eq, Eq FixityDirection
Eq FixityDirection
-> (FixityDirection -> FixityDirection -> Ordering)
-> (FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> Bool)
-> (FixityDirection -> FixityDirection -> FixityDirection)
-> (FixityDirection -> FixityDirection -> FixityDirection)
-> Ord FixityDirection
FixityDirection -> FixityDirection -> Bool
FixityDirection -> FixityDirection -> Ordering
FixityDirection -> FixityDirection -> FixityDirection
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FixityDirection -> FixityDirection -> FixityDirection
$cmin :: FixityDirection -> FixityDirection -> FixityDirection
max :: FixityDirection -> FixityDirection -> FixityDirection
$cmax :: FixityDirection -> FixityDirection -> FixityDirection
>= :: FixityDirection -> FixityDirection -> Bool
$c>= :: FixityDirection -> FixityDirection -> Bool
> :: FixityDirection -> FixityDirection -> Bool
$c> :: FixityDirection -> FixityDirection -> Bool
<= :: FixityDirection -> FixityDirection -> Bool
$c<= :: FixityDirection -> FixityDirection -> Bool
< :: FixityDirection -> FixityDirection -> Bool
$c< :: FixityDirection -> FixityDirection -> Bool
compare :: FixityDirection -> FixityDirection -> Ordering
$ccompare :: FixityDirection -> FixityDirection -> Ordering
$cp1Ord :: Eq FixityDirection
Ord, Int -> FixityDirection -> String -> String
[FixityDirection] -> String -> String
FixityDirection -> String
(Int -> FixityDirection -> String -> String)
-> (FixityDirection -> String)
-> ([FixityDirection] -> String -> String)
-> Show FixityDirection
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [FixityDirection] -> String -> String
$cshowList :: [FixityDirection] -> String -> String
show :: FixityDirection -> String
$cshow :: FixityDirection -> String
showsPrec :: Int -> FixityDirection -> String -> String
$cshowsPrec :: Int -> FixityDirection -> String -> String
Show, Typeable FixityDirection
DataType
Constr
Typeable FixityDirection
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FixityDirection)
-> (FixityDirection -> Constr)
-> (FixityDirection -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FixityDirection))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FixityDirection))
-> ((forall b. Data b => b -> b)
    -> FixityDirection -> FixityDirection)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> FixityDirection -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FixityDirection -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> FixityDirection -> m FixityDirection)
-> Data FixityDirection
FixityDirection -> DataType
FixityDirection -> Constr
(forall b. Data b => b -> b) -> FixityDirection -> FixityDirection
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityDirection
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) -> FixityDirection -> u
forall u. (forall d. Data d => d -> u) -> FixityDirection -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityDirection
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FixityDirection)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityDirection)
$cInfixN :: Constr
$cInfixR :: Constr
$cInfixL :: Constr
$tFixityDirection :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
gmapMp :: (forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
gmapM :: (forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> FixityDirection -> m FixityDirection
gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> FixityDirection -> u
gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FixityDirection -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FixityDirection -> r
gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection
$cgmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityDirection)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FixityDirection)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c FixityDirection)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FixityDirection)
dataTypeOf :: FixityDirection -> DataType
$cdataTypeOf :: FixityDirection -> DataType
toConstr :: FixityDirection -> Constr
$ctoConstr :: FixityDirection -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityDirection
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FixityDirection
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FixityDirection -> c FixityDirection
$cp1Data :: Typeable FixityDirection
Data, (forall x. FixityDirection -> Rep FixityDirection x)
-> (forall x. Rep FixityDirection x -> FixityDirection)
-> Generic FixityDirection
forall x. Rep FixityDirection x -> FixityDirection
forall x. FixityDirection -> Rep FixityDirection x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FixityDirection x -> FixityDirection
$cfrom :: forall x. FixityDirection -> Rep FixityDirection x
Generic )

-- | Highest allowed operator precedence for 'Fixity' constructor (answer: 9)
maxPrecedence :: Int
maxPrecedence :: Int
maxPrecedence = (Int
9::Int)

-- | Default fixity: @infixl 9@
defaultFixity :: Fixity
defaultFixity :: Fixity
defaultFixity = Int -> FixityDirection -> Fixity
Fixity Int
maxPrecedence FixityDirection
InfixL


{-
Note [Unresolved infix]
~~~~~~~~~~~~~~~~~~~~~~~
-}
{- $infix #infix#
When implementing antiquotation for quasiquoters, one often wants
to parse strings into expressions:

> parse :: String -> Maybe Exp

But how should we parse @a + b * c@? If we don't know the fixities of
@+@ and @*@, we don't know whether to parse it as @a + (b * c)@ or @(a
+ b) * c@.

In cases like this, use 'UInfixE', 'UInfixP', or 'UInfixT', which stand for
\"unresolved infix expression/pattern/type\", respectively. When the compiler
is given a splice containing a tree of @UInfixE@ applications such as

> UInfixE
>   (UInfixE e1 op1 e2)
>   op2
>   (UInfixE e3 op3 e4)

it will look up and the fixities of the relevant operators and
reassociate the tree as necessary.

  * trees will not be reassociated across 'ParensE', 'ParensP', or 'ParensT',
    which are of use for parsing expressions like

    > (a + b * c) + d * e

  * 'InfixE', 'InfixP', and 'InfixT' expressions are never reassociated.

  * The 'UInfixE' constructor doesn't support sections. Sections
    such as @(a *)@ have no ambiguity, so 'InfixE' suffices. For longer
    sections such as @(a + b * c -)@, use an 'InfixE' constructor for the
    outer-most section, and use 'UInfixE' constructors for all
    other operators:

    > InfixE
    >   Just (UInfixE ...a + b * c...)
    >   op
    >   Nothing

    Sections such as @(a + b +)@ and @((a + b) +)@ should be rendered
    into 'Exp's differently:

    > (+ a + b)   ---> InfixE Nothing + (Just $ UInfixE a + b)
    >                    -- will result in a fixity error if (+) is left-infix
    > (+ (a + b)) ---> InfixE Nothing + (Just $ ParensE $ UInfixE a + b)
    >                    -- no fixity errors

  * Quoted expressions such as

    > [| a * b + c |] :: Q Exp
    > [p| a : b : c |] :: Q Pat
    > [t| T + T |] :: Q Type

    will never contain 'UInfixE', 'UInfixP', 'UInfixT', 'InfixT', 'ParensE',
    'ParensP', or 'ParensT' constructors.

-}

-----------------------------------------------------
--
--      The main syntax data types
--
-----------------------------------------------------

data Lit = CharL Char
         | StringL String
         | IntegerL Integer     -- ^ Used for overloaded and non-overloaded
                                -- literals. We don't have a good way to
                                -- represent non-overloaded literals at
                                -- the moment. Maybe that doesn't matter?
         | RationalL Rational   -- Ditto
         | IntPrimL Integer
         | WordPrimL Integer
         | FloatPrimL Rational
         | DoublePrimL Rational
         | StringPrimL [Word8]  -- ^ A primitive C-style string, type 'Addr#'
         | BytesPrimL Bytes     -- ^ Some raw bytes, type 'Addr#':
         | CharPrimL Char
    deriving( Int -> Lit -> String -> String
[Lit] -> String -> String
Lit -> String
(Int -> Lit -> String -> String)
-> (Lit -> String) -> ([Lit] -> String -> String) -> Show Lit
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Lit] -> String -> String
$cshowList :: [Lit] -> String -> String
show :: Lit -> String
$cshow :: Lit -> String
showsPrec :: Int -> Lit -> String -> String
$cshowsPrec :: Int -> Lit -> String -> String
Show, Lit -> Lit -> Bool
(Lit -> Lit -> Bool) -> (Lit -> Lit -> Bool) -> Eq Lit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Lit -> Lit -> Bool
$c/= :: Lit -> Lit -> Bool
== :: Lit -> Lit -> Bool
$c== :: Lit -> Lit -> Bool
Eq, Eq Lit
Eq Lit
-> (Lit -> Lit -> Ordering)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Lit)
-> (Lit -> Lit -> Lit)
-> Ord Lit
Lit -> Lit -> Bool
Lit -> Lit -> Ordering
Lit -> Lit -> Lit
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Lit -> Lit -> Lit
$cmin :: Lit -> Lit -> Lit
max :: Lit -> Lit -> Lit
$cmax :: Lit -> Lit -> Lit
>= :: Lit -> Lit -> Bool
$c>= :: Lit -> Lit -> Bool
> :: Lit -> Lit -> Bool
$c> :: Lit -> Lit -> Bool
<= :: Lit -> Lit -> Bool
$c<= :: Lit -> Lit -> Bool
< :: Lit -> Lit -> Bool
$c< :: Lit -> Lit -> Bool
compare :: Lit -> Lit -> Ordering
$ccompare :: Lit -> Lit -> Ordering
$cp1Ord :: Eq Lit
Ord, Typeable Lit
DataType
Constr
Typeable Lit
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Lit -> c Lit)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Lit)
-> (Lit -> Constr)
-> (Lit -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Lit))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit))
-> ((forall b. Data b => b -> b) -> Lit -> Lit)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r)
-> (forall u. (forall d. Data d => d -> u) -> Lit -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Lit -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Lit -> m Lit)
-> Data Lit
Lit -> DataType
Lit -> Constr
(forall b. Data b => b -> b) -> Lit -> Lit
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lit -> c Lit
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lit
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) -> Lit -> u
forall u. (forall d. Data d => d -> u) -> Lit -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lit
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lit -> c Lit
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Lit)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)
$cCharPrimL :: Constr
$cBytesPrimL :: Constr
$cStringPrimL :: Constr
$cDoublePrimL :: Constr
$cFloatPrimL :: Constr
$cWordPrimL :: Constr
$cIntPrimL :: Constr
$cRationalL :: Constr
$cIntegerL :: Constr
$cStringL :: Constr
$cCharL :: Constr
$tLit :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Lit -> m Lit
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
gmapMp :: (forall d. Data d => d -> m d) -> Lit -> m Lit
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
gmapM :: (forall d. Data d => d -> m d) -> Lit -> m Lit
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Lit -> m Lit
gmapQi :: Int -> (forall d. Data d => d -> u) -> Lit -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Lit -> u
gmapQ :: (forall d. Data d => d -> u) -> Lit -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Lit -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r
gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit
$cgmapT :: (forall b. Data b => b -> b) -> Lit -> Lit
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Lit)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Lit)
dataTypeOf :: Lit -> DataType
$cdataTypeOf :: Lit -> DataType
toConstr :: Lit -> Constr
$ctoConstr :: Lit -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lit
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Lit
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lit -> c Lit
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Lit -> c Lit
$cp1Data :: Typeable Lit
Data, (forall x. Lit -> Rep Lit x)
-> (forall x. Rep Lit x -> Lit) -> Generic Lit
forall x. Rep Lit x -> Lit
forall x. Lit -> Rep Lit x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Lit x -> Lit
$cfrom :: forall x. Lit -> Rep Lit x
Generic )

    -- We could add Int, Float, Double etc, as we do in HsLit,
    -- but that could complicate the
    -- supposedly-simple TH.Syntax literal type

-- | Raw bytes embedded into the binary.
--
-- Avoid using Bytes constructor directly as it is likely to change in the
-- future. Use helpers such as `mkBytes` in Language.Haskell.TH.Lib instead.
data Bytes = Bytes
   { Bytes -> ForeignPtr Word8
bytesPtr    :: ForeignPtr Word8 -- ^ Pointer to the data
   , Bytes -> Word
bytesOffset :: Word             -- ^ Offset from the pointer
   , Bytes -> Word
bytesSize   :: Word             -- ^ Number of bytes
   -- Maybe someday:
   -- , bytesAlignement  :: Word -- ^ Alignement constraint
   -- , bytesReadOnly    :: Bool -- ^ Shall we embed into a read-only
   --                            --   section or not
   -- , bytesInitialized :: Bool -- ^ False: only use `bytesSize` to allocate
   --                            --   an uninitialized region
   }
   deriving (Bytes -> Bytes -> Bool
(Bytes -> Bytes -> Bool) -> (Bytes -> Bytes -> Bool) -> Eq Bytes
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Bytes -> Bytes -> Bool
$c/= :: Bytes -> Bytes -> Bool
== :: Bytes -> Bytes -> Bool
$c== :: Bytes -> Bytes -> Bool
Eq,Eq Bytes
Eq Bytes
-> (Bytes -> Bytes -> Ordering)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bool)
-> (Bytes -> Bytes -> Bytes)
-> (Bytes -> Bytes -> Bytes)
-> Ord Bytes
Bytes -> Bytes -> Bool
Bytes -> Bytes -> Ordering
Bytes -> Bytes -> Bytes
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Bytes -> Bytes -> Bytes
$cmin :: Bytes -> Bytes -> Bytes
max :: Bytes -> Bytes -> Bytes
$cmax :: Bytes -> Bytes -> Bytes
>= :: Bytes -> Bytes -> Bool
$c>= :: Bytes -> Bytes -> Bool
> :: Bytes -> Bytes -> Bool
$c> :: Bytes -> Bytes -> Bool
<= :: Bytes -> Bytes -> Bool
$c<= :: Bytes -> Bytes -> Bool
< :: Bytes -> Bytes -> Bool
$c< :: Bytes -> Bytes -> Bool
compare :: Bytes -> Bytes -> Ordering
$ccompare :: Bytes -> Bytes -> Ordering
$cp1Ord :: Eq Bytes
Ord,Typeable Bytes
DataType
Constr
Typeable Bytes
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Bytes -> c Bytes)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bytes)
-> (Bytes -> Constr)
-> (Bytes -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bytes))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes))
-> ((forall b. Data b => b -> b) -> Bytes -> Bytes)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r)
-> (forall u. (forall d. Data d => d -> u) -> Bytes -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bytes -> m Bytes)
-> Data Bytes
Bytes -> DataType
Bytes -> Constr
(forall b. Data b => b -> b) -> Bytes -> Bytes
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
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) -> Bytes -> u
forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bytes)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
$cBytes :: Constr
$tBytes :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Bytes -> m Bytes
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
gmapMp :: (forall d. Data d => d -> m d) -> Bytes -> m Bytes
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
gmapM :: (forall d. Data d => d -> m d) -> Bytes -> m Bytes
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bytes -> m Bytes
gmapQi :: Int -> (forall d. Data d => d -> u) -> Bytes -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bytes -> u
gmapQ :: (forall d. Data d => d -> u) -> Bytes -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Bytes -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r
gmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes
$cgmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Bytes)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bytes)
dataTypeOf :: Bytes -> DataType
$cdataTypeOf :: Bytes -> DataType
toConstr :: Bytes -> Constr
$ctoConstr :: Bytes -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bytes
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bytes -> c Bytes
$cp1Data :: Typeable Bytes
Data,(forall x. Bytes -> Rep Bytes x)
-> (forall x. Rep Bytes x -> Bytes) -> Generic Bytes
forall x. Rep Bytes x -> Bytes
forall x. Bytes -> Rep Bytes x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Bytes x -> Bytes
$cfrom :: forall x. Bytes -> Rep Bytes x
Generic,Int -> Bytes -> String -> String
[Bytes] -> String -> String
Bytes -> String
(Int -> Bytes -> String -> String)
-> (Bytes -> String) -> ([Bytes] -> String -> String) -> Show Bytes
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Bytes] -> String -> String
$cshowList :: [Bytes] -> String -> String
show :: Bytes -> String
$cshow :: Bytes -> String
showsPrec :: Int -> Bytes -> String -> String
$cshowsPrec :: Int -> Bytes -> String -> String
Show)


-- | Pattern in Haskell given in @{}@
data Pat
  = LitP Lit                        -- ^ @{ 5 or \'c\' }@
  | VarP Name                       -- ^ @{ x }@
  | TupP [Pat]                      -- ^ @{ (p1,p2) }@
  | UnboxedTupP [Pat]               -- ^ @{ (\# p1,p2 \#) }@
  | UnboxedSumP Pat SumAlt SumArity -- ^ @{ (\#|p|\#) }@
  | ConP Name [Pat]                 -- ^ @data T1 = C1 t1 t2; {C1 p1 p1} = e@
  | InfixP Pat Name Pat             -- ^ @foo ({x :+ y}) = e@
  | UInfixP Pat Name Pat            -- ^ @foo ({x :+ y}) = e@
                                    --
                                    -- See "Language.Haskell.TH.Syntax#infix"
  | ParensP Pat                     -- ^ @{(p)}@
                                    --
                                    -- See "Language.Haskell.TH.Syntax#infix"
  | TildeP Pat                      -- ^ @{ ~p }@
  | BangP Pat                       -- ^ @{ !p }@
  | AsP Name Pat                    -- ^ @{ x \@ p }@
  | WildP                           -- ^ @{ _ }@
  | RecP Name [FieldPat]            -- ^ @f (Pt { pointx = x }) = g x@
  | ListP [ Pat ]                   -- ^ @{ [1,2,3] }@
  | SigP Pat Type                   -- ^ @{ p :: t }@
  | ViewP Exp Pat                   -- ^ @{ e -> p }@
  deriving( Int -> Pat -> String -> String
[Pat] -> String -> String
Pat -> String
(Int -> Pat -> String -> String)
-> (Pat -> String) -> ([Pat] -> String -> String) -> Show Pat
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Pat] -> String -> String
$cshowList :: [Pat] -> String -> String
show :: Pat -> String
$cshow :: Pat -> String
showsPrec :: Int -> Pat -> String -> String
$cshowsPrec :: Int -> Pat -> String -> String
Show, Pat -> Pat -> Bool
(Pat -> Pat -> Bool) -> (Pat -> Pat -> Bool) -> Eq Pat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pat -> Pat -> Bool
$c/= :: Pat -> Pat -> Bool
== :: Pat -> Pat -> Bool
$c== :: Pat -> Pat -> Bool
Eq, Eq Pat
Eq Pat
-> (Pat -> Pat -> Ordering)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Pat)
-> (Pat -> Pat -> Pat)
-> Ord Pat
Pat -> Pat -> Bool
Pat -> Pat -> Ordering
Pat -> Pat -> Pat
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Pat -> Pat -> Pat
$cmin :: Pat -> Pat -> Pat
max :: Pat -> Pat -> Pat
$cmax :: Pat -> Pat -> Pat
>= :: Pat -> Pat -> Bool
$c>= :: Pat -> Pat -> Bool
> :: Pat -> Pat -> Bool
$c> :: Pat -> Pat -> Bool
<= :: Pat -> Pat -> Bool
$c<= :: Pat -> Pat -> Bool
< :: Pat -> Pat -> Bool
$c< :: Pat -> Pat -> Bool
compare :: Pat -> Pat -> Ordering
$ccompare :: Pat -> Pat -> Ordering
$cp1Ord :: Eq Pat
Ord, Typeable Pat
DataType
Constr
Typeable Pat
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pat -> c Pat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pat)
-> (Pat -> Constr)
-> (Pat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat))
-> ((forall b. Data b => b -> b) -> Pat -> Pat)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pat -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pat -> m Pat)
-> Data Pat
Pat -> DataType
Pat -> Constr
(forall b. Data b => b -> b) -> Pat -> Pat
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
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) -> Pat -> u
forall u. (forall d. Data d => d -> u) -> Pat -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
$cViewP :: Constr
$cSigP :: Constr
$cListP :: Constr
$cRecP :: Constr
$cWildP :: Constr
$cAsP :: Constr
$cBangP :: Constr
$cTildeP :: Constr
$cParensP :: Constr
$cUInfixP :: Constr
$cInfixP :: Constr
$cConP :: Constr
$cUnboxedSumP :: Constr
$cUnboxedTupP :: Constr
$cTupP :: Constr
$cVarP :: Constr
$cLitP :: Constr
$tPat :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapMp :: (forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapM :: (forall d. Data d => d -> m d) -> Pat -> m Pat
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pat -> m Pat
gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pat -> u
gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pat -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r
gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
$cgmapT :: (forall b. Data b => b -> b) -> Pat -> Pat
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Pat)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pat)
dataTypeOf :: Pat -> DataType
$cdataTypeOf :: Pat -> DataType
toConstr :: Pat -> Constr
$ctoConstr :: Pat -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pat
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pat -> c Pat
$cp1Data :: Typeable Pat
Data, (forall x. Pat -> Rep Pat x)
-> (forall x. Rep Pat x -> Pat) -> Generic Pat
forall x. Rep Pat x -> Pat
forall x. Pat -> Rep Pat x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Pat x -> Pat
$cfrom :: forall x. Pat -> Rep Pat x
Generic )

type FieldPat = (Name,Pat)

data Match = Match Pat Body [Dec] -- ^ @case e of { pat -> body where decs }@
    deriving( Int -> Match -> String -> String
[Match] -> String -> String
Match -> String
(Int -> Match -> String -> String)
-> (Match -> String) -> ([Match] -> String -> String) -> Show Match
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Match] -> String -> String
$cshowList :: [Match] -> String -> String
show :: Match -> String
$cshow :: Match -> String
showsPrec :: Int -> Match -> String -> String
$cshowsPrec :: Int -> Match -> String -> String
Show, Match -> Match -> Bool
(Match -> Match -> Bool) -> (Match -> Match -> Bool) -> Eq Match
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Match -> Match -> Bool
$c/= :: Match -> Match -> Bool
== :: Match -> Match -> Bool
$c== :: Match -> Match -> Bool
Eq, Eq Match
Eq Match
-> (Match -> Match -> Ordering)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Bool)
-> (Match -> Match -> Match)
-> (Match -> Match -> Match)
-> Ord Match
Match -> Match -> Bool
Match -> Match -> Ordering
Match -> Match -> Match
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Match -> Match -> Match
$cmin :: Match -> Match -> Match
max :: Match -> Match -> Match
$cmax :: Match -> Match -> Match
>= :: Match -> Match -> Bool
$c>= :: Match -> Match -> Bool
> :: Match -> Match -> Bool
$c> :: Match -> Match -> Bool
<= :: Match -> Match -> Bool
$c<= :: Match -> Match -> Bool
< :: Match -> Match -> Bool
$c< :: Match -> Match -> Bool
compare :: Match -> Match -> Ordering
$ccompare :: Match -> Match -> Ordering
$cp1Ord :: Eq Match
Ord, Typeable Match
DataType
Constr
Typeable Match
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Match -> c Match)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Match)
-> (Match -> Constr)
-> (Match -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Match))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match))
-> ((forall b. Data b => b -> b) -> Match -> Match)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
-> (forall u. (forall d. Data d => d -> u) -> Match -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Match -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Match -> m Match)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match)
-> Data Match
Match -> DataType
Match -> Constr
(forall b. Data b => b -> b) -> Match -> Match
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
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) -> Match -> u
forall u. (forall d. Data d => d -> u) -> Match -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
$cMatch :: Constr
$tMatch :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Match -> m Match
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapMp :: (forall d. Data d => d -> m d) -> Match -> m Match
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapM :: (forall d. Data d => d -> m d) -> Match -> m Match
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Match -> u
gmapQ :: (forall d. Data d => d -> u) -> Match -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Match -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
gmapT :: (forall b. Data b => b -> b) -> Match -> Match
$cgmapT :: (forall b. Data b => b -> b) -> Match -> Match
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Match)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match)
dataTypeOf :: Match -> DataType
$cdataTypeOf :: Match -> DataType
toConstr :: Match -> Constr
$ctoConstr :: Match -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
$cp1Data :: Typeable Match
Data, (forall x. Match -> Rep Match x)
-> (forall x. Rep Match x -> Match) -> Generic Match
forall x. Rep Match x -> Match
forall x. Match -> Rep Match x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Match x -> Match
$cfrom :: forall x. Match -> Rep Match x
Generic )
data Clause = Clause [Pat] Body [Dec]
                                  -- ^ @f { p1 p2 = body where decs }@
    deriving( Int -> Clause -> String -> String
[Clause] -> String -> String
Clause -> String
(Int -> Clause -> String -> String)
-> (Clause -> String)
-> ([Clause] -> String -> String)
-> Show Clause
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [Clause] -> String -> String
$cshowList :: [Clause] -> String -> String
show :: Clause -> String
$cshow :: Clause -> String
showsPrec :: Int -> Clause -> String -> String
$cshowsPrec :: Int -> Clause -> String -> String
Show, Clause -> Clause -> Bool
(Clause -> Clause -> Bool)
-> (Clause -> Clause -> Bool) -> Eq Clause
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Clause -> Clause -> Bool
$c/= :: Clause -> Clause -> Bool
== :: Clause -> Clause -> Bool
$c== :: Clause -> Clause -> Bool
Eq, Eq Clause
Eq Clause
-> (Clause -> Clause -> Ordering)
-> (Clause -> Clause -> Bool)
-> (Clause -> Clause -> Bool)
-> (Clause -> Clause -> Bool)
-> (Clause -> Clause -> Bool)
-> (Clause -> Clause -> Clause)
-> (Clause -> Clause -> Clause)
-> Ord Clause
Clause -> Clause -> Bool
Clause -> Clause -> Ordering
Clause -> Clause -> Clause
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Clause -> Clause -> Clause
$cmin :: Clause -> Clause -> Clause
max :: Clause -> Clause -> Clause
$cmax :: Clause -> Clause -> Clause
>= :: Clause -> Clause -> Bool
$c>= :: Clause -> Clause -> Bool
> :: Clause -> Clause -> Bool
$c> :: Clause -> Clause -> Bool
<= :: Clause -> Clause -> Bool
$c<= :: Clause -> Clause -> Bool
< :: Clause -> Clause -> Bool
$c< :: Clause -> Clause -> Bool
compare :: Clause -> Clause -> Ordering
$ccompare :: Clause -> Clause -> Ordering
$cp1Ord :: Eq Clause
Ord, Typeable Clause
DataType
Constr
Typeable Clause
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Clause -> c Clause)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Clause)
-> (Clause -> Constr)
-> (Clause -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Clause))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause))
-> ((forall b. Data b => b -> b) -> Clause -> Clause)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Clause -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Clause -> r)
-> (forall u. (forall d. Data d => d -> u) -> Clause -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Clause -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Clause -> m Clause)
-> Data Clause
Clause -> DataType
Clause -> Constr
(forall b. Data b => b -> b) -> Clause -> Clause
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause -> c Clause
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clause
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) -> Clause -> u
forall u. (forall d. Data d => d -> u) -> Clause -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clause
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause -> c Clause
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Clause)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)
$cClause :: Constr
$tClause :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Clause -> m Clause
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
gmapMp :: (forall d. Data d => d -> m d) -> Clause -> m Clause
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
gmapM :: (forall d. Data d => d -> m d) -> Clause -> m Clause
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Clause -> m Clause
gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Clause -> u
gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Clause -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r
gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause
$cgmapT :: (forall b. Data b => b -> b) -> Clause -> Clause
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Clause)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Clause)
dataTypeOf :: Clause -> DataType
$cdataTypeOf :: Clause -> DataType
toConstr :: Clause -> Constr
$ctoConstr :: Clause -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clause
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Clause
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause -> c Clause
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Clause -> c Clause
$cp1Data :: Typeable Clause
Data, (forall x. Clause -> Rep Clause x)
-> (forall x. Rep Clause x -> Clause) -> Generic Clause
forall x. Rep Clause x -> Clause
forall x. Clause -> Rep Clause x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Clause x -> Clause
$cfrom :: forall x. Clause -> Rep Clause x
Generic )

data Exp
  = VarE Name                          -- ^ @{ x }@
  | ConE Name                          -- ^ @data T1 = C1 t1 t2; p = {C1} e1 e2  @
  | LitE Lit                           -- ^ @{ 5 or \'c\'}@
  | AppE Exp Exp                       -- ^ @{ f x }@
  | AppTypeE Exp Type                  -- ^ @{ f \@Int }@

  | InfixE (Maybe Exp) Exp (Maybe Exp) -- ^ @{x + y} or {(x+)} or {(+ x)} or {(+)}@

    -- It's a bit gruesome to use an Exp as the operator when a Name
    -- would suffice. Historically, Exp was used to make it easier to
    -- distinguish between infix constructors and non-constructors.
    -- This is a bit overkill, since one could just as well call
    -- `startsConId` or `startsConSym` (from `GHC.Lexeme`) on a Name.
    -- Unfortunately, changing this design now would involve lots of
    -- code churn for consumers of the TH API, so we continue to use
    -- an Exp as the operator and perform an extra check during conversion
    -- to ensure that the Exp is a constructor or a variable (#16895).

  | UInfixE Exp Exp Exp                -- ^ @{x + y}@
                                       --
                                       -- See "Language.Haskell.TH.Syntax#infix"
  | ParensE Exp                        -- ^ @{ (e) }@
                                       --
                                       -- See "Language.Haskell.TH.Syntax#infix"
  | LamE [Pat] <