Smalltalk / Squeak消息处理方法(Smalltalk / Squeak message handling method)

 要回答这个问题，知道什么是准引用是有帮助的。 从GHC文档中 ，准引号是一个值 
 
data QuasiQuoter = QuasiQuoter { quoteExp  :: String -> Q Exp,
                                 quotePat  :: String -> Q Pat,
                                 quoteType :: String -> Q Type,
                                 quoteDec  :: String -> Q [Dec] }
 
 也就是说，它是从任意String到ExpQ ， PatQ ， TypeQ和DecQ一个或多个的DecQ ，它们分别是表达式，模式，类型和声明的模板Haskell表示。 
 
 当您使用准引号时，GHC将解析器应用于String以创建ExpQ （或其他类型），然后在生成的模板haskell表达式中拼接以生成实际值。 
 
 听起来你要做的就是将quasiquote解析和拼接分开，这样你就可以访问TH表达式了。 然后您可以将该表达式导入另一个模块并自己将其拼接在那里。 
 
 知道准引物的类型，很明显这是可能的。 通常你使用QQ作为 
 
-- file Expr.hs
eval :: Expr -> Integer
expr = QuasiQuoter { quoteExp = parseExprExp, quotePat =  parseExprPat }

-- file Foo.hs
import Expr
myInt = eval [expr|1 + 2|]
 
 相反，您可以自己提取解析器，获取TH表达式，然后将其拼接： 
 
-- file Foo.hs
import Expr

-- run the QQ parser
myInt_TH :: ExpQ
myInt_TH = quoteExp expr "1 + 2"

-- file Bar.hs
import Foo.hs

-- run the TH splice
myInt = $(myInt_TH)
 
 当然，如果您自己编写所有这些内容，则可以跳过准引号并直接使用解析器和模板Haskell。 这两种方式几乎都是一样的。 

To answer this, it's helpful to know what a quasi-quoter is. From the GHC Documentation, a quasi-quoter is a value of
 
data QuasiQuoter = QuasiQuoter { quoteExp  :: String -> Q Exp,
                                 quotePat  :: String -> Q Pat,
                                 quoteType :: String -> Q Type,
                                 quoteDec  :: String -> Q [Dec] }
 
That is, it's a parser from an arbitrary String to one or more of ExpQ, PatQ, TypeQ, and DecQ, which are Template Haskell representations of expressions, patterns, types, and declarations respectively.
 
When you use a quasi-quote, GHC applies the parser to the String to create a ExpQ (or other type), then splices in the resulting template haskell expression to produce an actual value.
 
It sounds like what you're asking to do is separate the quasiquote parsing and splicing, so that you have access to the TH expression. Then you can import that expression into another module and splice it there yourself.
 
Knowing the type of a quasi-quoter, it's readily apparent this is possible. Normally you use a QQ as
 
-- file Expr.hs
eval :: Expr -> Integer
expr = QuasiQuoter { quoteExp = parseExprExp, quotePat =  parseExprPat }

-- file Foo.hs
import Expr
myInt = eval [expr|1 + 2|]
 
Instead, you can extract the parser yourself, get a TH expression, and splice it later:
 
-- file Foo.hs
import Expr

-- run the QQ parser
myInt_TH :: ExpQ
myInt_TH = quoteExp expr "1 + 2"

-- file Bar.hs
import Foo.hs

-- run the TH splice
myInt = $(myInt_TH)
 
Of course if you're writing all this yourself, you can skip the quasi-quotes and use a parser and Template Haskell directly. It's pretty much the same thing either way.