有没有一种简单的方法来引用具有约束参数的类型？

如何解决有没有一种简单的方法来引用具有约束参数的类型？

> {-# LANGUAGE TemplateHaskell #-}
> import Language.Haskell.TH
> import Control.Monad

假设我有一个类 Default

> class Default a where
>  def :: a

有一种简单的方法可以为也有 Monoid 实例的类型定义实例，例如

instance Monoid a => Default a where
  def = mempty

但由于重叠问题，为了使这个更可控，可能会提供一个 TH 宏。

^{（是的，我知道我们可以使用 -XDerivingVia，我对这里的解决方案不感兴趣。）}

> makeMonoidDefault :: Q Type -> DecsQ
> makeMonoidDefault instT = sequence
>   [ InstanceD nothing [] <$> [t| Default $instT |] <*> [d|
>         $(varP $ mkName "def") = mempty |] ]

这可以用带引号的类型轻松调用，例如

makeMonoidDefault [t| Maybe () |]

允许

*Main> def :: Maybe ()
nothing

但这不允许像参数化实例这样的东西

instance Semigroup a => Default (Maybe a) where
  def = mempty

这可以用另一个宏来完成：

> makeMonoidDefault' :: Q (Cxt,Type) -> DecsQ
> makeMonoidDefault' cxtInstT = do
>  (cxt,instT) <- cxtInstT
>  sequence
>   [ InstanceD nothing cxt <*> [t| Default $(pure instT) |] <*> [d|
>         $(varP $ mkName "def") = mempty |] ]

但是现在实际使用起来更加尴尬：

makeMonoidDefault' $ do
   tParam <- pure . VarT <$> newName "a"
   sgcxt <- [t| Semigroup $tParam |]
   maybet <- [t| Maybe $tParam |]
   return ([sgcxt],maybet)

或

makeMonoidDefault' $ do
   tParam <- pure . VarT <$> newName "a"
   ((,) . (:[])) <$> [t| Semigroup $tParam |]
                 <*> [t| Maybe $tParam |]

• 有没有一种方法可以在不显式使用 VarT 和应用组合器的情况下编写此代码，最好使用单引号？
• makeMonoidDefault' 的参数是否应该不是 Q (Cxt,Type)？

解决方法

我想出的一个hacky解决方案是这样的：

-- Quote.hs
{-# LANGUAGE TemplateHaskell #-}
module Quote where

import Language.Haskell.TH

class Default a where
  def :: a

makeMonoidDefault' :: Q Type -> DecsQ
makeMonoidDefault' q = do
  t <- q
  case t of
    ForallT _ cxt instT -> sequence
      [ InstanceD Nothing cxt <$> [t| Default $(pure instT) |] <*> [d|
            $(varP 'def) = mempty |] ]
    _ -> fail "<some nice error message>"

然后你可以这样使用它：

-- Main.hs
{-# LANGUAGE TemplateHaskell,ExplicitForAll #-}
import Quote

makeMonoidDefault' [t|forall a. Semigroup a => Maybe a|]

main = pure ()

,

基于@Noughtmare 的解决方案，您可以在引号中执行更多操作：

{-# LANGUAGE ConstraintKinds #-}

makeMonoidDefault :: Q Type -> DecsQ
makeMonoidDefault q = do
  t <- q
  let (ctx,instT) = case t of
        ForallT _ ctx instT -> (ctx,instT)
        _ -> ([],t)
  [d|
    instance $(pure $ foldCtx ctx) => Default $(pure instT) where
      def = mempty
    |]
  where
    foldCtx l = foldl AppT (TupleT $ length l) l

它可以用于以下任何一种方式：

makeMonoidDefault [t|forall a. Semigroup a => Maybe a|]
makeMonoidDefault [t|forall a b. (Monoid a,Monoid b) => (a,b)|]
makeMonoidDefault [t|Maybe ()|]

并且它不再有关于 def 的奇怪之处。 （顺便说一句，ConstraintKinds pragma 对于没有上下文的情况是必需的，并且生成的上下文是 ()。）

,

一种选择是稍微改变设计。例如：

makeMonoidDefault [d| instance Semigroup a => Default (Maybe a) |]

这有点多余，因为它提到了 Default 两次。 （并且您确实应该检查它是否确实声明了您期望的类。）但从好的方面来说，它为您提供了许多作为参数一部分所需的结构。