Скрытие унаследованной реализации родительского класса case в scala

Я не совсем уверен, что вы здесь ищете, но на основе вашего описания это то, что я получил:

class SkewedClass(values: Int*) {
    lazy val skew: Int = {
        values.sum * 1234
    }
}

case class MyClass1(value1: Int, value2: Int) extends SkewedClass(value1, value2)
case class MyClass2(value1: Int, value2: Int, value3: Int) extends SkewedClass(value1, value2, value3)

Замените реализацию перекоса на любую сложную функцию, которую вы хотите использовать.

В этом случае вы хотите, чтобы все ваши структуры имели общее свойство Skew, но не обязательно какие-либо другие детали. Лучшее решение — просто использовать здесь трейт.

trait Skew {
  def skewCondition: Boolean
  lazy val skew: Int = if (skewCondition) RandomInt() else 0
}

case class AlwaysSkew(v1: Int, v2: Int) extends Skew {
  override val skewCondition: Boolean = true
}

case class ConditionalSkew(v1: Int, v2: Int) extends Skew {
  override val skewCondition: Boolean = (v1 != 500) && (v2 != 700)
}

val x = ConditionalSkew(500, 700)
val y = ConditionalSkew(1234,5678)
x.skew //0
y.skew //A random Int

Если вы хотите скрыть детали реализации skew, вы можете использовать собственный тип scala.

trait SkewTrait {
   def skew: Int
}


// package MyClass1
sealed class SkewClass1(value1: Int, value2: Int) {
this: SkewTrait =>
override def skew: Int = if (value1 == 500 && value2 == 700) 3 else 0
}

case class MyClass1(value1:Int, value2: Int) extends SkewClass1(value1, value2) with SkewTrait


// package MyClass2
sealed class SkewClass2(value1: Int) {
   this: SkewTrait =>
   override def skew: Int = if (value1 == 300) 4 else 0
}

case class MyClass2(value1: Int, value2: Int) extends SkewClass2(value1) with SkewTrait


println(MyClass1(1,2).skew)
println(MyClass2(300,5).skew)

результат:

0
4

Вы не можете создать case class с полями, которые инициализируются из других полей, но вы можете использовать для этого объект класса. Начните с функции для вычисления перекоса:

def computeSkew(value1: Int, value2: Int) =
  if (value1 == 500 && value2 == 700) 0 else Random.nextInt()

Затем используйте объект класса для создания его экземпляров:

case class MyClass1 private(value1: Int, value2: Int, skew: Int)

object MyClass1 {
  def apply(value1: Int, value2: Int): MyClass1 =
    MyClass1(value1, value2, computeSkew(value1, value2))
}

Другой вариант — добавить поле, расширив класс Skew, но объекты с одинаковыми value1 и value2 всегда будут сравниваться как равные, потому что skew не будет включен в тест equals.

Как упоминалось в комментариях, я не уверен, что добавление skew к основным объектам данных — это правильный способ решения проблемы дублирования. Было бы лучше обернуть skew вокруг объекта при использовании его в таблице и сохранить исходные данные нетронутыми.

Простая оболочка будет выглядеть так:

case class WithSkew[T] private(data: T, skew: Int)

object WithSkew {
  def apply[T](data: T): WithSkew[T] =
    WithSkew(data, Random.nextInt())
}

val x = MyClass1(500, 700)
val xSkew = WithSkew(x)

Затем вы используете xSkew в таблице, чтобы избежать дублирования, и извлекаете поле data, когда вы снова удаляете строки из таблицы.

Предыдущая версия не выполняет пользовательский расчет перекоса на основе value1 и value2. Это можно решить, введя класс типов, чтобы дать расчет перекоса для определенного класса:

trait HasSkew[T] {
  def skew(instance: T): Int
}

case class DefaultSkew[T]() extends HasSkew[T] {
  def skew(instance: T): Int = Random.nextInt()
}

object HasSkew {
  implicit object skew1 extends HasSkew[MyClass1] {
    def skew(data: MyClass1): Int =
      computeSkew(data.value1, data.value2)
  }
}

case class WithSkew[T] private(data: T, skew: Int)

object WithSkew {
  def apply[T](data: T)(implicit sk: HasSkew[T] = DefaultSkew[T]()): WithSkew[T] =
    WithSkew(data, sk.skew(data))
}

Оболочка WithSkew будет использовать расчет перекоса в DefaultSkew, если только для этого класса не существует неявного экземпляра HasSkew.

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