tl；dr：我应该怎么做，比如下面这些虚构的代码：

def notFunctor[M[_] : Not[Functor]](m: M[_]) = s"$m is not a functor"

“Not[Functor]”，这里是虚构的部分。
当提供的‘m’不是函数器时，我希望它成功，否则使编译器失败。

已解决：跳过剩下的问题，直接进入下面的答案。

粗略地说，我想要做的是“负面证据”。
伪代码如下所示：

// 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)的容器类型，以及定义了FixedSizeOf的元素，我们可以提高性能。
对于其余的案例，我们将检查收集的数据并计算各个尺寸的总和。
我的问题是同时为容器定义了Length和Foldable，并为元素定义了FixedSizeOf。这在这里是非常常见的情况(例如：List[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))

我希望的是，只有当Length+FixedSizeOf组合不适用时，才能依赖Foldable类型类。
为此，我可以更改foldSizeOf()的定义以接受VarSizeOf元素：

implicit def foldSizeOfVar[T[_] : Foldable, A : VarSizeOf] = // ...

现在我们必须填充包含FixedSizeOf元素和*未定义Length*的Foldable容器的有问题的部分。我不确定如何实现这一点，但伪代码应该类似于：

implicit def foldSizeOfFixed[T[_] : Foldable : Not[Length], A : FixedSizeOf] = // ...

显然，‘Not[Length]’是这里虚构的部分。

我知道的部分解决方案

1)为低优先级定义一个类，隐含并扩展它，如‘object Predef extends LowPriorityImplicits’所示。最后一个隐式(foldSizeOfFixed())可以在父类中定义，并将被子类中的替换项覆盖。
我对这个选项不感兴趣，因为我希望最终能够支持SizeOf的递归使用，这将防止低优先级基类中的隐式依赖于子类中的那些(我的理解正确吗？编辑：错误！隐式查找从子类的上下文中工作，这是一个可行的解决方案！)
2)更粗糙的方法是依赖Option[TypeClass](例如：Option[Length[List]])。其中的几个，我可以只写一个大的ol‘隐式，选择Foldable和SizeOf作为必选的，选择Length和FixedSizeOf作为可选的，并依赖于后者(如果它们可用)。(来源：here)
这里的两个问题是缺乏模块化和在找不到相关的类型类示例时回退到运行时异常(此示例可能可以与此解决方案一起使用，但这并不总是可能的)
编辑：这是我所能得到的最好的可选暗示。它还不在那里：

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()冲突之外，这仍然是必要的。
感谢您的帮助或观点：-)