+    sequenceQName, newNameName, liftName, liftTypedName,

+thSyn, thMonad, thLib, qqLib, liftLib :: Module

+thMonad = mkTHModule (fsLit "GHC.Internal.TH.Monad")

+

+libFun, libTc, thFun, thTc, thCon, liftFun, thMonadTc, thMonadCls, thMonadFun :: FastString -> Unique -> Name

+thMonadTc  = mk_known_key_name tcName thMonad

+thMonadCls = mk_known_key_name clsName thMonad

+thMonadFun = mk_known_key_name varName thMonad

+thMonadFld :: FastString -> FastString -> Unique -> Name

+thMonadFld con = mk_known_key_name (fieldName con) thSyn

+quoteClassName = thMonadCls (fsLit "Quote") quoteClassKey

+qTyConName             = thMonadTc (fsLit "Q")         qTyConKey

+codeTyConName          = thMonadTc (fsLit "Code")      codeTyConKey

+sequenceQName, newNameName, liftName,

+sequenceQName  = thMonadFun (fsLit "sequenceQ") sequenceQIdKey

+newNameName    = thMonadFun (fsLit "newName")   newNameIdKey

+unTypeName     = thMonadFld (fsLit "TExp") (fsLit "unType") unTypeIdKey

+unTypeCodeName    = thMonadFun (fsLit "unTypeCode") unTypeCodeIdKey

+unsafeCodeCoerceName = thMonadFun (fsLit "unsafeCodeCoerce") unsafeCodeCoerceIdKey

+sequenceQIdKey, liftIdKey, newNameIdKey,

+import qualified GHC.Boot.TH.Monad as TH (Q)

+  newName (unpackString "x"#) >>= \ x1::Name ->

+  lamE (varP x1) (varE x1)

+  newName (unpackString "x"#) >>= \ x1::Name ->

+  lamE (varP x1) (f (varE x1))

+import qualified GHC.Boot.TH.Monad  as TH (Q)

+import qualified GHC.Boot.TH.Monad  as TH

+import qualified GHC.Boot.TH.Monad as TH

+import qualified GHC.Boot.TH.Monad  as TH

+import GHC.Internal.TH.Monad

+import qualified GHC.Internal.TH.Monad as TH

+{-# LANGUAGE Safe #-}

+{-# OPTIONS_HADDOCK not-home #-}

+module GHC.Boot.TH.Monad

+  (module GHC.Internal.TH.Monad) where

+

+import GHC.Internal.TH.Monad

+{-# LANGUAGE Safe #-}

+            GHC.Boot.TH.Monad

+            GHC.Internal.TH.Monad

+            GHC.Boot.TH.Syntax,

+            GHC.Boot.TH.Monad

+        GHC.Internal.TH.Monad

+import qualified GHC.Internal.TH.Syntax as TH

+

+----------------------------------------------------------------------------

+-- Data instances for GHC.Internal.TH.Syntax

+

+deriving instance Data TH.AnnLookup

+deriving instance Data TH.AnnTarget

+deriving instance Data TH.Bang

+deriving instance Data TH.BndrVis

+deriving instance Data TH.Body

+deriving instance Data TH.Bytes

+deriving instance Data TH.Callconv

+deriving instance Data TH.Clause

+deriving instance Data TH.Con

+deriving instance Data TH.Dec

+deriving instance Data TH.DecidedStrictness

+deriving instance Data TH.DerivClause

+deriving instance Data TH.DerivStrategy

+deriving instance Data TH.DocLoc

+deriving instance Data TH.Exp

+deriving instance Data TH.FamilyResultSig

+deriving instance Data TH.Fixity

+deriving instance Data TH.FixityDirection

+deriving instance Data TH.Foreign

+deriving instance Data TH.FunDep

+deriving instance Data TH.Guard

+deriving instance Data TH.Info

+deriving instance Data TH.InjectivityAnn

+deriving instance Data TH.Inline

+deriving instance Data TH.Lit

+deriving instance Data TH.Loc

+deriving instance Data TH.Match

+deriving instance Data TH.ModName

+deriving instance Data TH.Module

+deriving instance Data TH.ModuleInfo

+deriving instance Data TH.Name

+deriving instance Data TH.NameFlavour

+deriving instance Data TH.NameSpace

+deriving instance Data TH.NamespaceSpecifier

+deriving instance Data TH.OccName

+deriving instance Data TH.Overlap

+deriving instance Data TH.Pat

+deriving instance Data TH.PatSynArgs

+deriving instance Data TH.PatSynDir

+deriving instance Data TH.Phases

+deriving instance Data TH.PkgName

+deriving instance Data TH.Pragma

+deriving instance Data TH.Range

+deriving instance Data TH.Role

+deriving instance Data TH.RuleBndr

+deriving instance Data TH.RuleMatch

+deriving instance Data TH.Safety

+deriving instance Data TH.SourceStrictness

+deriving instance Data TH.SourceUnpackedness

+deriving instance Data TH.Specificity

+deriving instance Data TH.Stmt

+deriving instance Data TH.TyLit

+deriving instance Data TH.TySynEqn

+deriving instance Data TH.Type

+deriving instance Data TH.TypeFamilyHead

+deriving instance Data flag => Data (TH.TyVarBndr flag)

+{-# LANGUAGE Trustworthy #-}

+import GHC.Internal.TH.Monad

+import GHC.Internal.TH.Monad

+{-# OPTIONS_HADDOCK not-home #-} -- we want users to import Language.Haskell.TH.Syntax instead

+{-# LANGUAGE CPP #-}

+{-# LANGUAGE DataKinds #-}

+{-# LANGUAGE FlexibleInstances #-}

+{-# LANGUAGE GADTs#-}

+{-# LANGUAGE PolyKinds #-}

+{-# LANGUAGE RankNTypes #-}

+{-# LANGUAGE RoleAnnotations #-}

+{-# LANGUAGE ScopedTypeVariables #-}

+{-# LANGUAGE StandaloneKindSignatures #-}

+{-# LANGUAGE Trustworthy #-}

+{-# LANGUAGE UnboxedSums #-}

+

+-- | This module is used internally in GHC's integration with Template Haskell

+-- and defines the Monads of Template Haskell, and associated definitions.

+--

+-- This is not a part of the public API, and as such, there are no API

+-- guarantees for this module from version to version.

+--

+-- Import "Language.Haskell.TH" or "Language.Haskell.TH.Syntax" instead!

+module GHC.Internal.TH.Monad

+    ( module GHC.Internal.TH.Monad

+    ) where

+

+#ifdef BOOTSTRAP_TH

+import Prelude

+import Data.Data hiding (Fixity(..))

+import Data.IORef

+import System.IO.Unsafe ( unsafePerformIO )

+import Control.Monad.IO.Class (MonadIO (..))

+import Control.Monad.Fix (MonadFix (..))

+import Control.Exception (BlockedIndefinitelyOnMVar (..), catch, throwIO)

+import Control.Exception.Base (FixIOException (..))

+import Control.Concurrent.MVar (newEmptyMVar, readMVar, putMVar)

+import System.IO        ( hPutStrLn, stderr )

+import qualified Data.Kind as Kind (Type)

+import GHC.IO.Unsafe    ( unsafeDupableInterleaveIO )

+import GHC.Types        (TYPE, RuntimeRep(..))

+#else

+import GHC.Internal.Base hiding (NonEmpty(..),Type, Module, sequence)

+import GHC.Internal.Data.Data hiding (Fixity(..))

+import GHC.Internal.Data.Traversable

+import GHC.Internal.IORef

+import GHC.Internal.System.IO

+import GHC.Internal.Data.Foldable

+import GHC.Internal.Data.Typeable

+import GHC.Internal.Control.Monad.IO.Class

+import GHC.Internal.Control.Monad.Fail

+import GHC.Internal.Control.Monad.Fix

+import GHC.Internal.Control.Exception

+import GHC.Internal.Num

+import GHC.Internal.IO.Unsafe

+import GHC.Internal.MVar

+import GHC.Internal.IO.Exception

+import qualified GHC.Internal.Types as Kind (Type)

+#endif

+import GHC.Internal.ForeignSrcLang

+import GHC.Internal.LanguageExtensions

+import GHC.Internal.TH.Syntax

+

+-----------------------------------------------------

+--

+--              The Quasi class

+--

+-----------------------------------------------------

+

+class (MonadIO m, MonadFail m) => Quasi m where

+  -- | Fresh names. See 'newName'.

+  qNewName :: String -> m Name

+

+  ------- Error reporting and recovery -------

+  -- | Report an error (True) or warning (False)

+  -- ...but carry on; use 'fail' to stop. See 'report'.

+  qReport  :: Bool -> String -> m ()

+

+  -- | See 'recover'.

+  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 -------

+  -- | True <=> type namespace, False <=> value namespace. See 'lookupName'.

+  qLookupName :: Bool -> String -> m (Maybe Name)

+  -- | See 'reify'.

+  qReify          :: Name -> m Info

+  -- | See 'reifyFixity'.

+  qReifyFixity    :: Name -> m (Maybe Fixity)

+  -- | See 'reifyType'.

+  qReifyType      :: Name -> m Type

+  -- | Is (n tys) an instance? Returns list of matching instance Decs (with

+  -- empty sub-Decs) Works for classes and type functions. See 'reifyInstances'.

+  qReifyInstances :: Name -> [Type] -> m [Dec]

+  -- | See 'reifyRoles'.

+  qReifyRoles         :: Name -> m [Role]

+  -- | See 'reifyAnnotations'.

+  qReifyAnnotations   :: Data a => AnnLookup -> m [a]

+  -- | See 'reifyModule'.

+  qReifyModule        :: Module -> m ModuleInfo

+  -- | See 'reifyConStrictness'.

+  qReifyConStrictness :: Name -> m [DecidedStrictness]

+

+  -- | See 'location'.

+  qLocation :: m Loc

+

+  -- | Input/output (dangerous). See 'runIO'.

+  qRunIO :: IO a -> m a

+  qRunIO = liftIO

+  -- | See 'getPackageRoot'.

+  qGetPackageRoot :: m FilePath

+

+  -- | See 'addDependentFile'.

+  qAddDependentFile :: FilePath -> m ()

+

+  -- | See 'addTempFile'.

+  qAddTempFile :: String -> m FilePath

+

+  -- | See 'addTopDecls'.

+  qAddTopDecls :: [Dec] -> m ()

+

+  -- | See 'addForeignFilePath'.

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

+

+  -- | See 'addModFinalizer'.

+  qAddModFinalizer :: Q () -> m ()

+

+  -- | See 'addCorePlugin'.

+  qAddCorePlugin :: String -> m ()

+

+  -- | See 'getQ'.

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

+

+  -- | See 'putQ'.

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

+

+  -- | See 'isExtEnabled'.

+  qIsExtEnabled :: Extension -> m Bool

+  -- | See 'extsEnabled'.

+  qExtsEnabled :: m [Extension]

+

+  -- | See 'putDoc'.

+  qPutDoc :: DocLoc -> String -> m ()

+  -- | See 'getDoc'.

+  qGetDoc :: DocLoc -> m (Maybe String)

+

+-----------------------------------------------------

+--      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 = newNameIO

+

+  qReport True  msg = hPutStrLn stderr ("Template Haskell error: " ++ msg)

+  qReport False msg = hPutStrLn stderr ("Template Haskell error: " ++ msg)

+

+  qLookupName _ _       = badIO "lookupName"

+  qReify _              = badIO "reify"

+  qReifyFixity _        = badIO "reifyFixity"

+  qReifyType _          = badIO "reifyFixity"

+  qReifyInstances _ _   = badIO "reifyInstances"

+  qReifyRoles _         = badIO "reifyRoles"

+  qReifyAnnotations _   = badIO "reifyAnnotations"

+  qReifyModule _        = badIO "reifyModule"

+  qReifyConStrictness _ = badIO "reifyConStrictness"

+  qLocation             = badIO "currentLocation"

+  qRecover _ _          = badIO "recover" -- Maybe we could fix this?

+  qGetPackageRoot       = badIO "getProjectRoot"

+  qAddDependentFile _   = badIO "addDependentFile"

+  qAddTempFile _        = badIO "addTempFile"

+  qAddTopDecls _        = badIO "addTopDecls"

+  qAddForeignFilePath _ _ = badIO "addForeignFilePath"

+  qAddModFinalizer _    = badIO "addModFinalizer"

+  qAddCorePlugin _      = badIO "addCorePlugin"

+  qGetQ                 = badIO "getQ"

+  qPutQ _               = badIO "putQ"

+  qIsExtEnabled _       = badIO "isExtEnabled"

+  qExtsEnabled          = badIO "extsEnabled"

+  qPutDoc _ _           = badIO "putDoc"

+  qGetDoc _             = badIO "getDoc"

+

+instance Quote IO where

+  newName = newNameIO

+

+newNameIO :: String -> IO Name

+newNameIO s = do { n <- atomicModifyIORef' counter (\x -> (x + 1, x))

+                 ; pure (mkNameU s n) }

+

+badIO :: String -> IO a

+badIO op = do   { qReport True ("Can't do `" ++ op ++ "' in the IO monad")

+                ; fail "Template Haskell failure" }

+

+-- Global variable to generate unique symbols

+counter :: IORef Uniq

+{-# NOINLINE counter #-}

+counter = unsafePerformIO (newIORef 0)

+

+

+-----------------------------------------------------

+--

+--              The Q monad

+--

+-----------------------------------------------------

+

+-- | In short, 'Q' provides the 'Quasi' operations in one neat monad for the

+-- user.

+--

+-- The longer story, is that 'Q' wraps an arbitrary 'Quasi'-able monad.

+-- The perceptive reader notices that 'Quasi' has only two instances, 'Q'

+-- itself and 'IO', neither of which have concrete implementations.'Q' plays

+-- the trick of [dependency

+-- inversion](https://en.wikipedia.org/wiki/Dependency_inversion_principle),

+-- providing an abstract interface for the user which is later concretely

+-- fufilled by an concrete 'Quasi' instance, internal to GHC.

+newtype Q a = Q { 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 m) = m

+

+instance Monad Q where

+  Q m >>= k  = Q (m >>= \x -> unQ (k x))

+  (>>) = (*>)

+

+instance MonadFail Q where

+  fail s     = report True s >> Q (fail "Q monad failure")

+

+instance Functor Q where

+  fmap f (Q x) = Q (fmap f x)

+

+instance Applicative Q where

+  pure x = Q (pure x)

+  Q f <*> Q x = Q (f <*> x)

+  Q m *> Q n = Q (m *> n)

+

+-- | @since 2.17.0.0

+instance Semigroup a => Semigroup (Q a) where

+  (<>) = liftA2 (<>)

+

+-- | @since 2.17.0.0

+instance Monoid a => Monoid (Q a) where

+  mempty = pure mempty

+

+-- | If the function passed to 'mfix' inspects its argument,

+-- the resulting action will throw a 'FixIOException'.

+--

+-- @since 2.17.0.0

+instance MonadFix Q where

+  -- We use the same blackholing approach as in fixIO.

+  -- See Note [Blackholing in fixIO] in System.IO in base.

+  mfix k = do

+    m <- runIO newEmptyMVar

+    ans <- runIO (unsafeDupableInterleaveIO

+             (readMVar m `catch` \BlockedIndefinitelyOnMVar ->

+                                    throwIO FixIOException))

+    result <- k ans

+    runIO (putMVar m result)

+    return result

+

+

+-----------------------------------------------------

+--

+--              The Quote class

+--

+-----------------------------------------------------

+

+

+

+-- | The 'Quote' class implements the minimal interface which is necessary for

+-- desugaring quotations.

+--

+-- * The @Monad m@ superclass is needed to stitch together the different

+-- AST fragments.

+-- * 'newName' is used when desugaring binding structures such as lambdas

+-- to generate fresh names.

+--

+-- Therefore the type of an untyped quotation in GHC is `Quote m => m Exp`

+--

+-- For many years the type of a quotation was fixed to be `Q Exp` but by

+-- more precisely specifying the minimal interface it enables the `Exp` to

+-- be extracted purely from the quotation without interacting with `Q`.

+class Monad m => Quote m where

+  {- |

+  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 -> m Name

+

+instance Quote Q where

+  newName s = Q (qNewName s)

+

+-----------------------------------------------------

+--

+--              The TExp type

+--

+-----------------------------------------------------

+

+type TExp :: TYPE r -> Kind.Type

+type role TExp nominal   -- See Note [Role of TExp]

+newtype TExp a = TExp

+  { unType :: Exp -- ^ Underlying untyped Template Haskell expression

+  }

+-- ^ Typed wrapper around an 'Exp'.

+--

+-- This is the typed representation of terms produced by typed quotes.

+--

+-- Representation-polymorphic since /template-haskell-2.16.0.0/.

+

+-- | Discard the type annotation and produce a plain Template Haskell

+-- expression

+--

+-- Representation-polymorphic since /template-haskell-2.16.0.0/.

+unTypeQ :: forall (r :: RuntimeRep) (a :: TYPE r) m . Quote m => m (TExp a) -> m Exp

+unTypeQ m = do { TExp e <- m

+               ; return 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.

+--

+-- Representation-polymorphic since /template-haskell-2.16.0.0/.

+unsafeTExpCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m .

+                      Quote m => m Exp -> m (TExp a)

+unsafeTExpCoerce m = do { e <- m

+                        ; return (TExp e) }

+

+{- Note [Role of TExp]

+~~~~~~~~~~~~~~~~~~~~~~

+TExp's argument must have a nominal role, not phantom as would

+be inferred (#8459).  Consider

+

+  e :: Code Q 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 (Code Q Age) to a (Code Q Int). -}

+

+-- Code constructor

+#if __GLASGOW_HASKELL__ >= 909

+type Code :: (Kind.Type -> Kind.Type) -> forall r. TYPE r -> Kind.Type

+  -- See Note [Foralls to the right in Code]

+#else

+type Code :: (Kind.Type -> Kind.Type) -> TYPE r -> Kind.Type

+#endif

+type role Code representational nominal   -- See Note [Role of TExp]

+newtype Code m a = Code

+  { examineCode :: m (TExp a) -- ^ Underlying monadic value

+  }

+-- ^ Represents an expression which has type @a@, built in monadic context @m@. Built on top of 'TExp', 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

+--     @Quote m => Code m a@

+--

+--   - typed splices inside of typed quotes, written as @$$(...)@ where @...@

+--     is an arbitrary expression of type @Quote m => Code m a@

+--

+-- Traditional expression quotes and splices let us construct ill-typed

+-- expressions:

+--

+-- >>> fmap ppr $ runQ (unTypeCode [| True == $( [| "foo" |] ) |])

+-- GHC.Internal.Types.True GHC.Internal.Classes.== "foo"

+-- >>> GHC.Internal.Types.True GHC.Internal.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 (unTypeCode [|| True == $$( [|| "foo" ||] ) ||])

+-- <interactive> error:

+--     • Couldn't match type ‘[Char]’ with ‘Bool’

+--       Expected type: Code Q Bool

+--         Actual type: Code Q [Char]

+--     • In the Template Haskell quotation [|| "foo" ||]

+--       In the expression: [|| "foo" ||]

+--       In the Template Haskell splice $$([|| "foo" ||])

+

+

+{- Note [Foralls to the right in Code]

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+Code has the following type signature:

+   type Code :: (Kind.Type -> Kind.Type) -> forall r. TYPE r -> Kind.Type

+

+This allows us to write

+   data T (f :: forall r . (TYPE r) -> Type) = MkT (f Int) (f Int#)

+

+   tcodeq :: T (Code Q)

+   tcodeq = MkT [||5||] [||5#||]

+

+If we used the slightly more straightforward signature

+   type Code :: foral r. (Kind.Type -> Kind.Type) -> TYPE r -> Kind.Type

+

+then the example above would become ill-typed.  (See #23592 for some discussion.)

+-}

+

+-- | Unsafely convert an untyped code representation into a typed code

+-- representation.

+unsafeCodeCoerce :: forall (r :: RuntimeRep) (a :: TYPE r) m .

+                      Quote m => m Exp -> Code m a

+unsafeCodeCoerce m = Code (unsafeTExpCoerce m)

+

+-- | Lift a monadic action producing code into the typed 'Code'

+-- representation

+liftCode :: forall (r :: RuntimeRep) (a :: TYPE r) m . m (TExp a) -> Code m a

+liftCode = Code

+

+-- | Extract the untyped representation from the typed representation

+unTypeCode :: forall (r :: RuntimeRep) (a :: TYPE r) m . Quote m

+           => Code m a -> m Exp

+unTypeCode = unTypeQ . examineCode

+

+-- | Modify the ambient monad used during code generation. For example, you

+-- can use `hoistCode` to handle a state effect:

+-- @

+--  handleState :: Code (StateT Int Q) a -> Code Q a

+--  handleState = hoistCode (flip runState 0)

+-- @

+hoistCode :: forall m n (r :: RuntimeRep) (a :: TYPE r) . Monad m

+          => (forall x . m x -> n x) -> Code m a -> Code n a

+hoistCode f (Code a) = Code (f a)

+

+

+-- | Variant of '(>>=)' which allows effectful computations to be injected

+-- into code generation.

+bindCode :: forall m a (r :: RuntimeRep) (b :: TYPE r) . Monad m

+         => m a -> (a -> Code m b) -> Code m b

+bindCode q k = liftCode (q >>= examineCode . k)

+

+-- | Variant of '(>>)' which allows effectful computations to be injected

+-- into code generation.

+bindCode_ :: forall m a (r :: RuntimeRep) (b :: TYPE r) . Monad m

+          => m a -> Code m b -> Code m b

+bindCode_ q c = liftCode ( q >> examineCode c)

+

+-- | A useful combinator for embedding monadic actions into 'Code'

+-- @

+-- myCode :: ... => Code m a