почему компилятор scala говорит, что аргументы типа не соответствуют границам? - PullRequest
Новая
       18

почему компилятор scala говорит, что аргументы типа не соответствуют границам?

0 голосов
/ 12 января 2019

Я создал черту Combiner с подклассами Complex и IntCombiner, и моя цель - заставить Matrix работать как с Complex, так и с Int. Но по некоторым причинам это не компилируется, говоря, что 

[com.implicits.TestImplicits1.IntCombiner] do not conform to class Matrix's type parameter bounds [T <: com.implicits.TestImplicits1.Combiner[T]]
    val m1 = new Matrix[IntCombiner](3, 3)((1 to 9).sliding(3).map {

Но, как я понимаю, IntContainer является подклассом Combiner, он должен работать. Почему такую ​​ошибку, пожалуйста, объясните? 

object TestImplicits1 {

  trait Combiner[T] {

    def +(b: T): T

    def *(b: T): T

  }

  class Complex(r: Double, i: Double) extends Combiner[Complex] {

    val real = r

    val im = i

    override def +(b: Complex): Complex = {
      new Complex(real + b.real, im + b.im)
    }

    override def *(b: Complex): Complex = {
      new Complex((real * b.real) - (im * b.im), real * b.im + b.real * im)
    }

  }

  class IntCombiner(a: Int) extends Combiner[Int] {
    val v = a

    override def *(b: Int): Int = v * b

    override def +(b: Int): Int = v + b

  }

  class Matrix[T <: Combiner[T]](x1: Int, y1: Int)(ma: Seq[Seq[T]]) {

    self =>
    val x: Int = x1
    val y: Int = y1

    def dot(v1: Seq[T], v2: Seq[T]): T = {
      v1.zip(v2).map { t: (T, T) => {
        t._1 * t._2
      }
      }.reduce(_ + _)
    }

  }

  object MatrixInt extends App {
    def apply[T <: Combiner[T]](x1: Int, y1: Int)(s: Seq[Seq[T]]) = {
      new Matrix[T](x1, y1)(s)
    }

    val m1 = new Matrix[IntCombiner](3, 3)((1 to 9).sliding(3).map {
      x => x map { y => new IntCombiner(y) }
    }.toSeq)
  }

}

1 Ответ

0 голосов
/ 12 января 2019

F-ограниченный полиморфизм не может быть добавлен к существующему классу Int, потому что Int - это просто то, что он есть, он ничего не знает о ваших Combiner чертах, поэтому он не может расширять Combiner[Int]. Вы можете обернуть каждый Int во что-то вроде IntWrapper <: Combiner[IntWrapper], но это потратит немало памяти, и дизайн библиотеки вокруг F-ограниченного полиморфизма имеет тенденцию быть хитрым.

Вот предложение, основанное на специальном полиморфизме и классах типов: 

object TestImplicits1 {

  trait Combiner[T] {
    def +(a: T, b: T): T
    def *(a: T, b: T): T
  }

  object syntax {
    object combiner {
      implicit class CombinerOps[A](a: A) {
        def +(b: A)(implicit comb: Combiner[A]) = comb.+(a, b)
        def *(b: A)(implicit comb: Combiner[A]) = comb.*(a, b)
      }
    }
  }

  case class Complex(re: Double, im: Double)

  implicit val complexCombiner: Combiner[Complex] = new Combiner[Complex] {

    override def +(a: Complex, b: Complex): Complex = {
      Complex(a.re + b.re, a.im + b.im)
    }

    override def *(a: Complex, b: Complex): Complex = {
      Complex((a.re * b.re) - (a.im * b.im), a.re * b.im + b.re * a.im)
    }

  }

  implicit val intCombiner: Combiner[Int] = new Combiner[Int] {
    override def *(a: Int, b: Int): Int = a * b
    override def +(a: Int, b: Int): Int = a + b
  }

  class Matrix[T: Combiner](entries: Vector[Vector[T]]) {
    def frobeniusNormSq: T = {
      import syntax.combiner._
      entries.map(_.map(x => x * x).reduce(_ + _)).reduce(_ + _)
    }
  }
}

Я не знаю, что вы пытались сделать с помощью dot, ваши x1, x2 и ma казались совершенно неиспользуемыми, поэтому я добавил вместо этого простой пример квадрата Фробениуса-нормы, просто чтобы показать, как классы типов и синтаксический сахар для операторов работают вместе. Пожалуйста, не ожидайте ничего похожего на «высокую производительность» - JVM традиционно никогда не заботился о прямоугольных массивах и сокращении чисел (по крайней мере, не на одном вычислительном узле; Spark & ​​Co - это отдельная история). По крайней мере, ваш код не будет автоматически перенесен в оптимизированный код CUDA, это точно.

...