Stack types for macro - scala

Question

For a macro implementation I'm stacking types and field names with this boilerplate code:
trait Init
trait A_ {
type Push[T]
val int: Push[Int] = ???
val str: Push[String] = ???
}
object A extends A_ {
type Push[T] = Init with B[Init with T]
}
trait B_ {
type Push[T]
val int: Push[Int] = ???
val str: Push[String] = ???
}
trait B[Stack] extends B_ {
type Push[T] = C[Stack with T]
}
trait C[Stack] // etc..
val x: Init with B[Init with Int] = A.int
val y: C[Init with Int with String] = A.int.str
val z: C[Init with String with Int] = A.str.int
// etc..
This works fine. The user can write A.int.str or A.str.int and the macro can easily extract the involved types and fields.
Since many more types and variations are involved, I'd like to replace A_ and B_ with a single base class if possible to avoid the redundancy. So I tried this:
trait AB {
type Push[T]
val int: Push[Int] = ???
val str: Push[String] = ???
}
object A extends AB {
type Push[T] = Init with B[Init with T]
}
trait B[Stack] extends AB {
type Push[T] = C[Stack with T]
}
trait C[Stack] // etc..
val x: Init with B[Init with Int] = A.int
val y: Init with B[Init with String] = A.int.str
But as you can see, y lost the Int type on the way.
When calling str, the Push type used is still the one defined in A. I had hoped for the returned Init with B[Init with T] to return a new instance of B[Stack] extends AB using its Push type leading to C and so on.
A self reference attempt fails too:
trait AB { self: {type Push[T]} =>
val int: Push[Int] = ???
val str: Push[String] = ???
}
object A extends AB {
type Push[T] = Init with B[Init with T]
}
trait B[Stack] extends AB {
type Push[T] = C[Stack with T]
}
trait C[Stack] // etc..
val x: A.Push[Int] = A.int
val y: A.Push[String] = A.int.str
I'm obviously missing something and another self reference implementation doesn't work either:
trait Pusher {
type Push[T] = _
}
trait AB { self: Pusher =>
val int: Push[Int] = ???
val str: Push[String] = ???
}
object A extends AB with Pusher {
override type Push[T] = Init with B[Init with T]
}
trait B[Stack] extends AB with Pusher {
override type Push[T] = C[Stack with T]
}
trait C[Stack] // etc..
val x: A.Push[Int] = A.int
val y: A.Push[String] = A.int.str
Is there a way to have a single implementation of int/str and get val y: C[Init with Int with String] = A.int.str (or something similar) that I can use to extract the types in the macro implementation?
UPDATE:
#AlinGabrielArhip is right in his comment that the type information is actually carried on and compiles even though the types of the second approaches with a single base class are not inferred correctly which show with red lines in IntelliJ.
To give more context to my question, here are the two approaches that you can test in the REPL:
Start scala with `scala -Yrepl-class-based:false´
Paste and run the following 4 sections of code one at a time:
object SetupA {
import scala.reflect.macros.blackbox
import scala.language.experimental.macros
trait Init
trait Name {
val name: String = ""
}
trait Age {
val age: Int = 0
}
trait Person0_base {
type Push[T]
val name: Push[Name] = ???
val age : Push[Age] = ???
}
object PersonA extends Person0_base {
type Push[T] = Init with Person1[Init with T]
}
trait Person1_base {
type Push[T]
val name: Push[Name] = ???
val age : Push[Age] = ???
}
trait Person1[Stack] extends Person1_base {
type Push[T] = Person2[Stack with T]
}
trait Person2[Stack]
def impl[T](c: blackbox.Context)(person: c.Tree): c.Tree = {
import c.universe._
q"""
new Init with Name with Age {
// Data fetched from db..
override val name = "Ben"
override val age = 42
}
"""
}
def macroA[T](person: Person2[T]): T = macro impl[T]
}
import SetupA._
// Correctly inferred as `Init with Name with Age`
val personA = macroA(PersonA.name.age)
personA.name == "Ben"
personA.age == 42
object SetupB {
import scala.reflect.macros.blackbox
import scala.language.experimental.macros
trait Init
trait Name {
val name: String = ""
}
trait Age {
val age: Int = 0
}
trait Person_base {
type Push[T]
val name: Push[Name] = ???
val age : Push[Age] = ???
}
object PersonB extends Person_base {
type Push[T] = Init with Person1[Init with T]
}
trait Person1[Stack] extends Person_base {
type Push[T] = Person2[Stack with T]
}
trait Person2[Stack] {
val get: Stack = ???
}
def impl[T](c: blackbox.Context)(person: c.Tree): c.Tree = {
import c.universe._
q"""
new Init with Name with Age {
// Data fetched from db..
override val name = "Ben"
override val age = 42
}
"""
}
def macroB[T](person: Person2[T]): T = macro impl[T]
}
import SetupB._
// Incorrectly inferred as `PersonB.Push[Age]` - but still compiles!
val personB = macroB(PersonB.name.age)
personB.name == "Ben"
personB.age == 42
Is there a workaround to get correct type inference in this case?

Answer 1

Had made this more complicated than necessary. By simply supplying Stack and Push as type parameters to the base class, type inference works as expected:
object Test {
import scala.reflect.macros.blackbox
import scala.language.experimental.macros
trait Init
trait Name {
val name: String = ""
}
trait Age {
val age: Int = 0
}
trait PersonBase[Stack, Push[_]] {
val name: Push[Stack with Name] = ???
val age : Push[Stack with Age] = ???
}
object Person extends PersonBase[Init, Person1]
trait Person1[Stack] extends PersonBase[Stack, Person2]
trait Person2[Stack] extends PersonBase[Stack, Person3]
trait Person3[Stack]
def impl[T](c: blackbox.Context)(person: c.Tree): c.Tree = {
import c.universe._
q"""
new Init with Name with Age {
// Data fetched from db...
override val name = "Ben"
override val age = 42
}
"""
}
def m[T](person: Person2[T]): T = macro impl[T]
}
import Test._
val person = m(Person.name.age)
person.name == "Ben"
person.age == 42
UPDATE:
Although this answer solves stacking types, it actually doesn't solve the broader problem that the initial use of abstract types was intended for. So I marked it as unanswered.
The problem behind is that the sub classes have varying type parameter arities. So they can't simply be passed as type parameters to a single base class (at least I haven't found a way to do that).
As #AlinGabrielArhip helped me find out, it's a type inference problem and I have submitted this bug report to IntelliJ.
So with a little better understanding of the problem, here's an example of what I want to get working which seems dependent on IntelliJ to fix the type inference bug:
scala -Yrepl-class-based:false
object Setup {
import scala.reflect.macros.blackbox
import scala.language.experimental.macros
trait Name {
val name: String = ""
}
trait Age {
val age: Int = -1
}
trait PersonAttributes {
type Next[Attr, Tpe]
val name: Next[Name, String] = ???
val age : Next[Age, Int] = ???
}
trait Person0[Obj] extends PersonAttributes {
type Next[Attr, Tpe] = Person1[Obj with Attr, Tpe]
}
trait Person1[Obj, A] extends PersonAttributes {
type Next[Attr, Tpe] = Person2[Obj with Attr, A, Tpe]
}
trait Person2[Obj, A, B] // etc..
def objImpl[Obj, A, B](c: blackbox.Context)(person2: c.Tree): c.Tree = {
import c.universe._
q"""
new Init with Name with Age {
// Data fetched from db..
override val name = "Ben"
override val age = 42
}
"""
}
def obj[Obj, A, B](person2: Person2[Obj, A, B]): Obj = macro objImpl[Obj, A, B]
}
import Setup._
trait Init
object Person extends Person0[Init]
// Incorrectly inferred as `PersonB.Push[Age]` - but still compiles!
// Should be inferred as: `Person2[Init with String with Int]`
val person = obj(Person.name.age)
person.name == "Ben"
person.age == 42
The initial code example in my question actually only works because A defines
type Push[T] = Init with B[Init with T]
instead of
type Push[T] = B[Init with T]
The added Init with just helped the type inference. But this "trick" doesn't work with the single base class approach.
So now, I simply hope for IntelliJ to fix the bug.