Question

灵感来自this blog post和this code我以为我会尝试使用其接口（类型类）在Idris中尝试一些类别理论。

我将Category定义如下，效果很好：

interface Category (obj : Type) (hom : obj -> obj -> Type) where
  id : {a : obj} -> hom a a
  comp : {a, b, c : obj} -> hom b c -> hom a b -> hom a c

然后，本着Verified模块的精神，我想我会定义一个经过验证的类别：

interface Category obj hom =>
          VerifiedCategory (obj : Type) (hom : obj -> obj -> Type) where
  categoryAssociativity : {a, b, c, d : obj} ->
                          (f : hom c d) -> (g : hom b c) -> (h : hom a b) ->
                          (comp (comp f g) h = comp f (comp g h))
  categoryLeftIdentity : {a, b : obj} -> (f : hom a b) -> (comp id f = f)
  categoryRightIdentity : {a, b : obj} -> (f : hom a b) -> (comp f id = f)

不幸的是，Idris使用以下错误消息拒绝该代码：

When checking type of constructor of CategoryTheory.VerifiedCategory:
Can't find implementation for Category obj hom

我做错了什么，或者我想尝试使用Idris无法做的多参数子类？

所有这些代码都在自己的模块中，名为CategoryTheory，没有任何导入。

我正在使用Idris v0.12。

Answer 1

我不知道为什么（并且很想知道为什么！）但是如果你在id中指定comp和VerifiedCategory的所有隐含参数，它就会起作用明确。想弄清楚这是非常丑陋和乏味的，但是这个样子：

interface Category obj hom => VerifiedCategory (obj : Type) (hom : obj -> obj -> Type) where
  categoryAssociativity : {a, b, c, d : obj} ->
                          (f : hom c d) ->
                          (g : hom b c) ->
                          (h : hom a b) ->
                          (comp {a = a} {b = b} {c = d} (comp {a = b} {b = c} {c = d} f g) h = comp {a = a} {b = c} {c = d} f (comp {a = a} {b = b} {c = c} g h))
  categoryLeftIdentity : {a, b : obj} ->
                         (f : hom a b) ->
                         (comp {a = a} {b = b} {c = b} (id {a = b}) f = f)
  categoryRightIdentity : {a, b : obj} ->
                          (f : hom a b) ->
                          (comp {a = a} {b = a} {c = b} f (id {a = a}) = f)

编辑：我刚才找到的另一种方法是明确地将hom指定为determining parameter，即足以找到实现的类型类的参数。这必须发生在Category以及VerifiedCategory中（我不确定，为什么），如下所示：

interface Category (obj : Type) (hom : obj -> obj -> Type) | hom where
-- ...

interface Category obj hom => VerifiedCategory (obj : Type) (hom : obj -> obj -> Type) where
-- ...

即。在| hom之前加where。

除此之外，您必须做的一件事是限定id中VerifiedCategory的使用，因为否则无论出于何种原因它都会被解释为隐式参数：

  categoryLeftIdentity : {a, b : obj} ->
                         (f : hom a b) ->
                         comp CategoryTheory.id f = f
  categoryRightIdentity : {a, b : obj} ->
                          (f : hom a b) ->
                          comp f CategoryTheory.id = f

另见this reddit线程，可能在将来有所启发。

Idris中的多参数子类

1 个答案: