Bug at type inference for structural types.

[shumy]

Compiler version

3.0.0-RC1

Minimized code

class Record(private val fields: Map[String, Any]) extends Selectable:
  def this(elems: (String, Any)*) = this(elems.toMap)
  def selectDynamic(name: String): Any = fields(name)

  infix def ::[I <: Record, O >: this.type & I](record: I): O =
    Record(fields ++ record.fields).asInstanceOf[O]

  def debug() =
    val elems = fields.map{ case (key, value) => s"${key}: ${value.getClass.getSimpleName.toString}" }
    s"{ ${elems.mkString(", ")} }"

  def toJson() =
    val elems = fields.map{ case (key, value) => s"${key}: ${value}" }
    s"{ ${elems.mkString(", ")} }"

object Record:
  def of[T <: Record](elems: (String, Any)*) = Record(elems.toMap).asInstanceOf[T]
  def obj[I <: Object](obj: I) = obj.asInstanceOf[Record]


extension [L <: Object](left: L)
  infix def &[R <: Object, O >: L & R](right: R): O =
    (left.asInstanceOf[Record] :: right.asInstanceOf[Record]).asInstanceOf[O]

@main def hello =
  type One = { val one: Int }
  type Two = { val two: Int }
  type Extended = { val one: Int; val two: Int }

  val one: One = Record.of("one" -> 1)
  val two: Two = Record.of("two" -> 2)
  val v1: One & Two = one & two
  val v2 = one & two
  
  val v3: Extended = v1
  val v4: Extended = v2
  
  val v5: Extended = one & two

  val record = Record.obj(one & two)
  println(Record.obj(v2).toJson())

Output

Found:    (two : Two)
Required: Object{one: Int; two: Int}

Expectation

line 38: val v5: Extended = one & two should work in the same way this works:

  val v3: Extended = v1
  val v4: Extended = v2

[odersky]

There's a lot of funkiness going on with casts here. It helps to print out the types with -Xprint:typer. I did that and found lots of issues. So, not convinced there is a bug. To continue we'd need a minimization and a concrete argument what should be inferred and why that is so.

[shumy]

I'm using scastie.scala-lang.org. Simplified version only with records on RC3:

class Record(elems: Map[String, Any]) extends Selectable:
  val fields = elems.toMap
  def selectDynamic(name: String): Any = fields(name)

extension [A <: Record] (a:A) {
  def join[B <: Record] (b:B): A & B = {
    Record(a.fields ++ b.fields).asInstanceOf[A & B]
  }
}

type Person = Record { val name: String; val age: Int }
type Child = Record { val parent: String }
type PersonAndChild = Record { val name: String; val age: Int; val parent: String }

@main def hello = {
  val person = Record(Map("name" -> "Emma", "age" -> 42)).asInstanceOf[Person]
  val child = Record(Map("parent" -> "Alice")).asInstanceOf[Child]
  val personAndChild = person.join(child)
  
  val v1: PersonAndChild = personAndChild
  val v2: PersonAndChild = person.join(child)
}

Assignment of v2 should work in the same way as assignment of v1.

[odersky]

Thanks for the minimization. I verified that both this and the original code work with #12317.

I am intrigued by what you are building. This goes very much in the direction of what I thought we should be able to do with the new structural types. What's your goal here? Do you want to use this in a library? Maybe write a paper about it? I think it would be an interesting submission for the Scala symposium or another Scala conference.

[shumy]

@odersky I'm exploring the potentials of Scala 3 type and meta programming. The initial idea was to use records for data sources where you can select the desired output (such as SQL, GrapthQL, etc). I want to select fields and the data source should produce a Record with the correct schema on compile time.

The other use case is to collect different records from those sources and build a new joined Record and joined data. Also verifiable at compile time.

So, the point is that there are no pre-defined schemas. These should all be constructed from the desired inputs via macros.