Проблема с переводом ограничений типа Scala в Java

Эээ, я думаю, это работает? Это в основном код Java, за исключением того, что некоторые взломы типов сделаны явными.

// The forSome type is not inferred
// Instead, I think this is where the wonky Comparable[_ >: What with Even <: Is] with This type comes from
val map = Map[Field[T, U] forSome { type T; type U <: Type[T] }, Any](
  field1 -> "abc",
  field2 -> boolean2Boolean(true)
  // field2 -> new AnyRef // works, there's no checking
)
val dataBuilder = new DataBuilder
// we know that key: Field[T, U] forSome { type T; type U <: Type[T] }
// the second match doesn't *do* anything, but it lets us name these
// two types something (here, t, u) and use them as type arguments to addEntry
map.foreach { case (key, value) => key match {
  case key: Field[t, u] => dataBuilder.addEntry[t, u](key, value.asInstanceOf[t])
} }

Излишне говорить, что я ненавижу это. Я думаю, что единственный способ сделать это разумным - это написать какой-то гетерогенный класс карты (хотя я не думаю, что даже shapeless HMap поможет здесь), но это сложно.

Вы можете использовать «разнородную карту». Гетерогенная карта - это карта, где ключи и значения могут иметь разные типы. Я не знаю ни одной существующей реализации гетерогенной карты с типобезопасностью, которая бы удовлетворяла вашим потребностям, но вот действительно простая реализация такой. Я думаю, что вам действительно нужна возможность использовать стандартные операции сбора на этой забавной карте, и это должно помочь в этом.

import scala.language.existentials
import scala.collection._

class HMap[K[_], V[_]](underlying: immutable.Map[K[_], V[_]] = immutable.Map.empty[K[_], V[_]])
  extends Iterable[(K[T], V[T]) forSome { type T }]
     with IterableOps[(K[T], V[T]) forSome { type T }, Iterable, HMap[K, V]] {
  // collections boilerplate
  override protected def fromSpecific(coll: IterableOnce[(K[T], V[T]) forSome { type T }]): HMap[K, V]
  = new HMap[K, V](immutable.Map.from(coll))
  override protected def newSpecificBuilder: mutable.Builder[(K[T], V[T]) forSome { type T }, HMap[K, V]]
  = immutable.Map.newBuilder[K[_], V[_]].mapResult(new HMap[K, V](_))
  override def empty: HMap[K, V] = new HMap[K, V]
  override def iterator: Iterator[(K[T], V[T]) forSome { type T }]
  = new Iterator[(K[T], V[T]) forSome { type T }] {
    val underlying = HMap.this.underlying.iterator
    override def hasNext: Boolean = underlying.hasNext
    override def next(): (K[T], V[T]) forSome { type T }
    = underlying.next().asInstanceOf[(K[T], V[T]) forSome { type T}]
  }

  // Mappy operations
  def get[T](k: K[T]): Option[V[T]] = underlying.get(k).map(_.asInstanceOf[V[T]])
  def +[T](kv: (K[T], V[T])): HMap[K, V] = new HMap[K, V](underlying + kv)
  def -[T](k: K[T]): HMap[K, V] = new HMap[K, V](underlying - k)
}
object HMap {
  // Mappy construction
  def apply[K[_], V[_]](elems: (K[T], V[T]) forSome { type T }*): HMap[K, V] = new HMap[K, V](immutable.Map(elems: _*))
}

Теперь все работает довольно аккуратно

type FieldOf[T] = Field[T, _ <: Type[T]]
type Id[T] = T
val map = HMap[FieldOf, Id](
  field1 -> "abc",
  field2 -> boolean2Boolean(true)
  // field2 -> new AnyRef // doesn't work, readable(-ish) error message
)
val dataBuilder = new DataBuilder
map.foreach { case (key, value) => dataBuilder.addEntry(key, value) }

Если экзистенциальные представления доставляют вам дискомфорт, следует заменить (K[T], V[T]) forSome { type T } на Prod[K, V, _], где

case class Prod[K[_], V[_], T](k: K[T], v: V[T])
object Prod {
    implicit def fromTup2[K[_], V[_], T](kv: (K[T], V[T])): Prod[K, V]
    = Prod(kv._1, kv._2)
}

(при необходимости, с некоторыми дополнительными изменениями)