Template Haskell refers to the template meta-programming facilities built into GHC Haskell. The paper describing the original implementation can be found here.
Stages refer to when code is executed. Normally, code is exectued only at runtime, but with Template Haskell, code can be executed at compile time. "Normal" code is stage 0 and compile-time code is stage 1.
The stage restriction refers to the fact that a stage 0 program may not be executed at stage 1 - this would be equivalent to being able to run any regular program (not just meta-program) at compile time.
By convention (and for the sake of implementation simplicity), code in the current module is always stage 0 and code imported from all other modules is stage 1. For this reason, only expressions from other modules may be spliced.
Note that a stage 1 program is a stage 0 expression of type
Q Type, etc; but the converse is not true - not every value (stage 0 program) of type
Q Exp is a stage 1 program,
Futhermore, since splices can be nested, identifiers can have stages greater than 1. The stage restriction can then be generalized - a stage n program may not be executed in any stage m>n. For example, one can see references to such stages greater than 1 in certain error messages:
>:t [| \x -> $x |] <interactive>:1:10: error: * Stage error: `x' is bound at stage 2 but used at stage 1 * In the untyped splice: $x In the Template Haskell quotation [| \ x -> $x |]
Normally, all the declarations in a single Haskell module can be thought of as all being mutually recursive. In other words, every top-level declaration is in the scope of every other in a single module. When Template Haskell is enabled, the scoping rules change - the module is instead broken into groups of code seperated by TH splices, and each group is mutually recursive, and each group in the scope of all further groups.