Можно ли в scala shapeless использовать литеральный тип в качестве универсального параметра типа c?

Question

Предполагается, что я пишу программу для векторного умножения. Следуя требованию этой статьи:

https://etrain.github.io/2015/05/28/type-safe-linear-algebra-in-scala

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

import shapeless.Witness

trait Axis extends Serializable

case object UnknownAxis extends Axis

trait KnownAxis[W <: Witness.Lt[Int]] extends Axis {

  def n: Int

  def ++(that: KnownAxis[W]): Unit = {}
}

object KnownAxis {

  val w1 = Witness(1)
  val w2 = Witness(2)

  case class K1(n: Witness.`1`.T) extends KnownAxis[w1.type]
  case class K2(n: Witness.`2`.T) extends KnownAxis[w2.type]

//  K2(2) ++ K1(1) // doesn't compile

  K2(2) ++ K2(2)
}

Пока все хорошо, проблема возникает, когда я попробуйте обобщить это для всех n:

  case class KN[W <: Witness.Lt[Int]](n: W#T) extends KnownAxis[W]

  KN(1)

Приведенный выше код вызывает ошибку компиляции:

Axis.scala:36: type mismatch;
 found   : Int(1)
 required: this.T
[ERROR]   KN(1)
[ERROR]      ^
[ERROR] one error found

Мой вопрос: почему Spark не может сосредоточиться на более изысканном типе Witness.`1`.T, вместо этого используется тип Int? Что нужно, чтобы переопределить это поведение, чтобы класс случая KN мог быть успешно определен?

ОБНОВЛЕНИЕ 1: Продолжение было перенесено в новый вопрос:

При использовании функции одиночного типа Scala бесформенный, как заставить компилятор использовать узкий / одиночный тип в качестве неявного параметра?

Answer 1

Не удивительно, что Scala не может вывести W при W#T, потому что, вообще говоря, два разных W могут иметь одинаковые W#T. Не для типов-свидетелей, но они не обрабатываются специально компилятором.

То, что я ожидал работать (и не уверен, почему это не так), это указать параметр типа:

KN[Witness.`1`](1)
// error: type arguments [scala.this.Any] do not conform to method apply's type parameter bounds [W <: shapeless.this.Witness.Lt[scala.this.Int]]

или более вероятно

KN[w1.type](1)
// error: type mismatch;
// found   : scala.this.Int(1)
// required: .this.T

Что работает:

case class KN[W <: Witness.Lt[Int]](w: W) extends KnownAxis[W] {
  val n = w.value
}

KN(Witness(1))

Кажется, это соответствует требованиям в вашем вопросе, но я не знаю, будет ли это работать с остальная часть вашего кода.

Вы также можете рассмотреть эту альтернативу, которая не требует Shapeless в Scala 2.13:

trait Axis extends Serializable

case object UnknownAxis extends Axis

trait KnownAxis[W <: Int with Singleton] extends Axis {

  def n: W

  def ++(that: KnownAxis[W]): Unit = {}
}

case class KN[W <: Int with Singleton](n: W) extends KnownAxis[W]

KN(1)

Для 2.12

import shapeless.syntax.singleton._

...
KN(1.narrow)

Answer 2

Попробуйте параметризовать KnownAxis с единичным подтипом Int

trait KnownAxis[N <: Int] extends Axis {
  def n: N
  def ++(that: KnownAxis[N]): Unit = {}
}

case class K1(n: Witness.`1`.T) extends KnownAxis[Witness.`1`.T]
case class K2(n: Witness.`2`.T) extends KnownAxis[Witness.`2`.T]

case class KN[N <: Int](n: N)(implicit w: Witness.Aux[N]) extends KnownAxis[N]

import shapeless.syntax.singleton._
KN[Witness.`1`.T](1.narrow)

или просто

KN[Witness.`1`.T](1)

Или с абстрактным классом вместо черты

abstract class KnownAxis[N <: Int](implicit w: Witness.Aux[N]) extends Axis {
  def n: N
  def ++(that: KnownAxis[N]): Unit = {}
}