Haskell 使用具有约束字段的数据类型代替约束

TL，DR扩展约束，即席。。。？我的路线是“健忘的”，或者说是不平衡的

大家好，我目前正在尝试制作一个重载函数，该函数可以接受约束（在我们的例子中是，

IsString

），也可以是具有相同约束字段的数据类型。以下是我目前的代码：

{-# LANGUAGE
    OverloadedStrings
  , FlexibleInstances
  , UndecidableInstances
  , InstanceSigs
  , TypeFamilies
#-}

import Data.Monoid

class Bar a where
  bar :: ( IsString b
         , Monoid b ) => a -> b

-- | This instance won't work.
instance ( IsString a
         , Monoid a ) => RelativeUrl a where
  bar :: ( IsString b
         , Monoid b
         , a ~ b ) => a -> b
  bar = id

-- | This is the data type "extending" @IsString@
data Foo a where
  Foo :: ( IsString a, Monoid a ) =>
         a -> Foo a

-- | This is where my dreams end :(
instance Bar (Foo a) where
  bar :: ( IsString b
         , Monoid b
         , a ~ b ) => a -> b
  bar (Foo a) = a

我意识到实例签名不符合犹太教，这就是为什么（技术上）这不起作用的原因，但是还有其他方法吗？理想情况下，我希望所有对

bar

的调用都能由上下文推断，这样

bar“foo”：：IsString a=>a

，而不必将重载字符串限制为实际类型

---

有没有其他方法可以做到这一点？我对疯狂的想法持开放态度：）

这个

Bar

类是关于能够转换成任何

IsString

的东西。我假定

Monoid

实例是为了某种效率而存在的。我们可以给

Bar

和

Bar

起更具启发性的名字

class ToStringPlus a where
  toStringPlus :: ( IsString b,
                    Monoid b ) => a -> b

您希望

条“foo”：：IsString a=>a

。启用了

重载字符串

“foo”：：IsString a->a。您正在询问如何将一个在

IsString

的所有实例上都是多态的值转换为一个在

IsString

的所有实例上都是多态的值。你不需要像

toStringPlus“foo”

这样的东西，只要使用

“foo”

隐藏IsString 如果您想为所有a打开类型

。IsString a=>a

转换为一种数据类型，您可以使用GADT来实现。它一点用处都没有，因为类型

的唯一可能值是a。IsString a=>a

是字符串x的

来源，其中
x:：String
。此类型可以保存与
String
完全相同的值，而
String
实用程序不提供任何值

{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE RankNTypes #-}

import Data.String

data AString where
    AString :: (forall a. IsString a => a) -> AString

instance IsString AString where
    fromString x = AString (fromString x)

instance ToStringPlus AString where
    toStringPlus (AString a) = a

更有用的东西
AString
不是很有用，因为它只能保存与
字符串相同的值。
ToStringPlus
类不仅允许使用
String
s转换为某些内容，还允许
mappend
、
mconcat
和
mempty
的
Monoid
操作。这表示所有a的类型
。（IsString a，幺半群a）=>a
应该能够保存不同于字符串的内容

data MonoidalString where
    MonoidalString :: (forall a. (IsString a, Monoid a) => a) -> MonoidalString

MonoidalString
s形成一个
Monoid
。请注意，
mconcat
和
mappend
由于秩N类型，无法以无点样式编写

instance Monoid MonoidalString where
    mempty = MonoidalString mempty
    (MonoidalString x) `mappend` (MonoidalString y) = MonoidalString (x `mappend` y)
    mconcat ms = MonoidalString (mconcat (map toStringPlus ms))

MonoidalString
s也可以是
IsString
和
ToStringPlus
的实例，方式与上一节中的
AString
相同

instance IsString MonoidalString where
    fromString x = MonoidalString (fromString x)

instance ToStringPlus MonoidalString where
    toStringPlus (MonoidalString a) = a

这让我们可以在一条评论中对您的请求赋予意义：“我正在尝试将在
IsString
和任何
Foo
[的所有实例中已经多态的东西转换为多态的东西…]”。我们可以使用
Monoid
操作将已经在
IsString
，
“poly string”
的所有实例上多态的东西与
monoidString
结合起来，以获得在
IsString
和
Monoid
的所有实例上多态的东西

给定一些
现有的：：MonoidalString
和
“poly string”：：IsString a=>a
我们可以将它们与
mappend
组合

                                      existing  :: MonoidalString
              "poly string"                     :: IsString a => a
              "poly string" `mappend` existing  :: MonoidalString
toStringPlus ("poly string" `mappend` existing) :: (Monoid b, IsString b) => b

我们可以用它制作一个小示例程序，展示
MonoidalString

main = do
    let existing = ("MS" :: MonoidalString)
    putStr . toStringPlus $ mconcat ["poly string", mempty `mappend` " ", existing]

    existing = ("MS" :: MonoidalString)
bar existing                            :: (Monoid a, IsString a) => a

再来一次吧
如果您想创建一个函数
bar
，它接受所有a的两种类型的参数
。ctxa=>a
和
D
只要有
实例ctxd
就可以这样做。然后，函数的类型是
D->…
。这是因为a
对于所有a。Ctx a=>a
可以在需要a
D
的任何地方使用

我们可以使用它为最后一个示例编写一个
条

bar :: (IsString a, Monoid a) => MonoidalString -> a
bar = toStringPlus

我们可以将多态字符串
传递到
bar
“foo”：：IsString a=>a

    "foo" :: IsString a => a
bar "foo"                    :: (Monoid a, IsString a) => a

我们还可以传递给bar一个单态的
MonoidalString
，
existing:：MonoidalString

main = do
    let existing = ("MS" :: MonoidalString)
    putStr . toStringPlus $ mconcat ["poly string", mempty `mappend` " ", existing]

    existing = ("MS" :: MonoidalString)
bar existing                            :: (Monoid a, IsString a) => a

编译器如何知道在没有“钳制”的情况下调用哪个类型的
bar
——将重载字符串下放到一个实际的类型？这就是问题所在。我正在尝试将所有
IsString
和任何
Foo
[的实例中已经多态的东西转换成多态的东西…]。在我的用例中，
toStringPlus
将实际返回
mb
（其中
m
是调用站点推断的另一个typeclass的实例）。如果我要键入强制
m
的推理，
toStringPlus
必须能够处理这两种情况。此外，Monoid实例只是为了给
IsString
添加和清空，以制作我自己的通用漂亮打印机。@AthanClark也许你应该问一下如何解决你的问题（描述你的问题）与其问编译器告诉您不要做的事情，不如问一下如何做。@AthanClark我添加了一些更有用的东西，可能与您正在寻找的内容有关。@AthanClark不，无法为秩n或限定类型创建实例。如果它确实存在，那么它的语法可能分别是
实例Ctx（forall a.a->a）where…
或
实例Ctx2（forall a.Ctx=>a）where…
。这两种情况都会导致错误“在…”的实例声明中出现非法多态或限定类型：…”。