Использование границ контекста "отрицательно", чтобы гарантировать, что экземпляр класса экземпляра отсутствует в области видимости

tl; dr: как мне сделать что-то вроде составленного кода ниже:

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, так и 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))

Я хотел бы иметь возможность полагаться на класс типа Foldable только тогда, когда комбинация Length + FixedSizeOf не применяется.

С этой целью я могу изменить определение foldSizeOf() для принятия элементов VarSizeOf:

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

И теперь мы должны заполнить проблематичную часть, которая охватывает контейнеры Foldable с элементами FixedSizeOf и no Length. Я не уверен, как подойти к этому, но псевдокод будет выглядеть примерно так:

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

"Not[Length]", очевидно, является составной частью здесь.

Частичные решения, о которых я знаю

1) Определите класс для невысоких приоритетов и продолжите его, как показано в 'object Predef extends LowPriorityImplicits'. Последний неявный (foldSizeOfFixed()) может быть определен в родительском классе и будет переопределен альтернативой из класса потомков.

Мне неинтересен этот параметр, потому что я хотел бы в конечном итоге поддерживать рекурсивное использование SizeOf, и это предотвратит использование неявного базового класса с низким приоритетом в подклассном классе (это мое понимание здесь правильно? EDIT: неправильный! неявный поиск работает из контекста подкласса, это жизнеспособное решение!)

2) Более грубый подход основан на Option[TypeClass] (например,: Option[Length[List]]. Некоторые из них и я могу просто написать один большой неявный символ, который выбирает Foldable и SizeOf как обязательные, и Length и FixedSizeOf как необязательные, и полагаются на последние, если они доступны. (источник: здесь)

Две проблемы здесь - отсутствие модульности и возврат к исключениям времени выполнения, когда не могут быть найдены соответствующие экземпляры класса типа (этот пример, вероятно, может быть сделан для работы с этим решением, но это не всегда возможно)

EDIT: Это лучшее, что я смог получить с дополнительными implicits. Это еще не все:

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(), что по-прежнему необходимо.

Спасибо за любую помощь или перспективу: -)