tl;博士：我该如何做类似下面的代码：
def notFunctor[M[_] : Not[Functor]](m: M[_]) = s"$m is not a functor"
' Not[Functor]'，是这里的组成部分。
我希望它在提供的“m”不是 Functor 时成功，否则编译器会失败。
已解决：跳过问题的其余部分，直接进入下面的答案。
粗略地说，我要完成的是“负面证据”。
伪代码看起来像这样：
// type class for obtaining serialization size in bytes.
trait SizeOf[A] { def sizeOf(a: A): Long }
// type class specialized for types whose size may vary between instances
trait VarSizeOf[A] extends SizeOf[A]
// type class specialized for types whose elements share the same size (e.g. Int)
trait FixedSizeOf[A] extends SizeOf[A] {
def fixedSize: Long
def sizeOf(a: A) = fixedSize
}
// SizeOf for container with fixed-sized elements and Length (using scalaz.Length)
implicit def fixedSizeOf[T[_] : Length, A : FixedSizeOf] = new VarSizeOf[T[A]] {
def sizeOf(as: T[A]) = ... // length(as) * sizeOf[A]
}
// SizeOf for container with scalaz.Foldable, and elements with VarSizeOf
implicit def foldSizeOf[T[_] : Foldable, A : SizeOf] = new VarSizeOf[T[A]] {
def sizeOf(as: T[A]) = ... // foldMap(a => sizeOf(a))
}
请记住，这fixedSizeOf()在相关时更可取，因为它为我们节省了遍历集合的时间。
这样，对于仅Length定义（但未定义Foldable）的容器类型，以及定义了 a 的元素FixedSizeOf，我们可以提高性能。
对于其余的情况，我们会检查集合并汇总各个大小。
我的问题是在为容器定义和Length为元素定义的情况下。这是一个非常常见的情况（例如：已经定义了两者）。FoldableFixedSizeOfList[Int]
例子：
scala> implicitly[SizeOf[List[Int]]].sizeOf(List(1,2,3))
<console>:24: error: ambiguous implicit values:
both method foldSizeOf of type [T[_], A](implicit evidence$1: scalaz.Foldable[T], implicit evidence$2: SizeOf[A])VarSizeOf[T[A]]
and method fixedSizeOf of type [T[_], A](implicit evidence$1: scalaz.Length[T], implicit evidence$2: FixedSizeOf[A])VarSizeOf[T[A]]
match expected type SizeOf[List[Int]]
implicitly[SizeOf[List[Int]]].sizeOf(List(1,2,3))
我想要的是Foldable只有在Length+FixedSizeOf组合不适用时才能依赖类型类。
为此，我可以更改foldSizeOf()接受VarSizeOf元素的定义：
implicit def foldSizeOfVar[T[_] : Foldable, A : VarSizeOf] = // ...
现在我们必须填写有问题的部分，即Foldable包含FixedSizeOf元素且未Length定义的容器。我不知道如何解决这个问题，但伪代码看起来像：
implicit def foldSizeOfFixed[T[_] : Foldable : Not[Length], A : FixedSizeOf] = // ...
' Not[Length]' 显然是这里的组成部分。
我知道的部分解决方案
1）为低优先级隐式定义一个类并扩展它，如' object Predef extends LowPriorityImplicits'所示。最后一个隐式 ( foldSizeOfFixed()) 可以在父类中定义，并将被后代类的替代覆盖。
我对这个选项不感兴趣，因为我希望最终能够支持递归使用SizeOf，这将防止低优先级基类中的隐含依赖于子类中的那些（我的理解是否正确？编辑: 错误！隐式查找从子类的上下文中工作，这是一个可行的解决方案！）
2）一种更粗略的方法是依赖于Option[TypeClass]（例如：Option[Length[List]]。其中一些，我可以只写一个大的隐式，选择Foldable和SizeOf作为强制性和Length和FixedSizeOf作为可选，如果它们可用，则依赖于后者。（来源：在这里）
这里的两个问题是缺乏模块化和在找不到相关类型类实例时回退到运行时异常（这个例子可能可以与这个解决方案一起工作，但这并不总是可能的）
编辑：这是我能够通过可选隐式获得的最好的。它还没有：
implicit def optionalTypeClass[TC](implicit tc: TC = null) = Option(tc)
type OptionalLength[T[_]] = Option[Length[T]]
type OptionalFixedSizeOf[T[_]] = Option[FixedSizeOf[T]]
implicit def sizeOfContainer[
T[_] : Foldable : OptionalLength,
A : SizeOf : OptionalFixedSizeOf]: SizeOf[T[A]] = new SizeOf[T[A]] {
def sizeOf(as: T[A]) = {
// optionally calculate using Length + FixedSizeOf is possible
val fixedLength = for {
lengthOf <- implicitly[OptionalLength[T]]
sizeOf <- implicitly[OptionalFixedSizeOf[A]]
} yield lengthOf.length(as) * sizeOf.fixedSize
// otherwise fall back to Foldable
fixedLength.getOrElse {
val foldable = implicitly[Foldable[T]]
val sizeOf = implicitly[SizeOf[A]]
foldable.foldMap(as)(a => sizeOf.sizeOf(a))
}
}
}
除了这与fixedSizeOf()之前的冲突，这仍然是必要的。
感谢您的任何帮助或观点:-)