Can scala abstract type can hold the type parameter?

Question

I have the following simple demo code, which give me the type mismatch error. I quite do not understand why this error happens. Would anyone show me how to fix this error. Further explain or related learning resource would be great thankful.

object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[T <: TypeHolder[_]](val holder: T) {

  def showElementType(t: T#ElementType): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

The compile error as:

Error:(10, 26) type mismatch;
 found   : Application.foo.type (with underlying type Foo)
 required: _$1
  client.showElementType(foo)

UPDATE at 2018-03-15

Just like Andrey Tyukin would be curious about what TypeHolder is used for, it contains nothing beyond T. I add some function on this trait.

Codes as follow.

object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T

  def holderFun(): Unit = println(s"holder, type:${getClass}")

  def elementFun(ele: ElementType): Unit = println(s"element, type:${getClass}")
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[T <: TypeHolder[_]](val holder: T) {

  def showElementType(t: T#ElementType): Unit = {
    println("show element type " + t.toString)
    holder.holderFun()
    holder.elementFun(t)
  }

}

which gives compile errors as below:

Error:(10, 26) type mismatch;
 found   : o2.Application.foo.type (with underlying type o2.Foo)
 required: _$1
  client.showElementType(foo)
Error:(30, 23) type mismatch;
 found   : _$1
 required: Client.this.holder.ElementType
    (which expands to)  _$1
    holder.elementFun(t)

On the whole, The core thing I want to know is:

when I instantiate client via val client = new Client(holder) while holder has the type: TypeHolder[Foo] Does scala compiler can infer the ElementType of hoder is "Foo"?

Thanks so much @Andrey for giving various workable solutions. I exam your code snippet 1~3, and compare with my code carefully, which makes me more clear now. However I still have some questions.

Version 3

This version of your code is closest to my original post code. The only difference is the type restriction of function showElementType

• Mine: def showElementType(t: T#ElementType): Unit
• Your: def showElementType(t: holder.ElementType): Unit

Which confuse me is, since "(t: holder.ElementType)" works, "(t: T#ElementType)" should work as well? And actually it isn't. why?

Version 2

The difference here is the location of type ElementType = T. I put it in the trait definition, while you put it in type parameter restriction.

• Mine: trait TypeHolder[T] { type ElementType = T}
• Your: class Client[T, H <: TypeHolder { type ElementType = T }]

I cannot understand why the assignment statement in trait definition isn't works.

Version 1

You use two type parameter T & H to capture the type of Foo and TypeHolder respectively. It should absolutely works. The type of client is also corresponding to Client[Foo, TypeHolder[Foo]]. My question is, is it possible to define client use only one type parameter, e.g. Client[TypeHolder[Foo]]. In other words, is it possible for the compiler to infer from the TypeHolder[Foo] that the ElementType is Foo?

Thank you.

Answer 1

This compiles after some modifications:

object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  // not sure why you try to use this one
  // client.showElementType(foo)
  // foo doesn't extend the Typeholder, it's just regular class

  // on the other hand this will compile
  client.showElementType(holder)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[T <: TypeHolder[_]](val holder: T) {

  // no need to use the #ElementType
  def showElementType(t: T): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

Hope this also helps:

What does the `#` operator mean in Scala?

https://github.com/ghik/opinionated-scala/wiki/Generics-and-type-members

As far as the error _$1 goes, it's just compiler saying: "I can't figure this one out"

Answer 2

I'm not sure what you tried here, but here is my version of "probably closest projection of the code into compilable Scala":

import scala.language.higherKinds
object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[T, H[X] <: TypeHolder[X]](val holder: H[T]) {
  def showElementType(t: T): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

but it might as well be this:

import scala.language.higherKinds
object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client[Foo, FooTypeHolder](holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder {
  type ElementType
}

class FooTypeHolder extends TypeHolder {
  type ElementType = Foo
}

class Client[T, H <: TypeHolder { type ElementType = T }](val holder: H) {
  def showElementType(t: T): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

or maybe this?:

import scala.language.higherKinds
object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder[T] {
  type ElementType = T
}

class FooTypeHolder extends TypeHolder[Foo]

class Client[H <: TypeHolder[_]](val holder: H) {
  def showElementType(t: holder.ElementType): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

---

What I fundamentally don't understand about your code is: what is the TypeHolder[T] supposed to do, exactly? The whole TypeHolder[T] construction doesn't seem to contain any information beyond T itself, so why not use T directly, like this?:

object Application extends App {
  private val foo = new Foo
  private val client = new Client[Foo]
  client.showElementType(foo)
}

class Foo

class Client[T] {
  def showElementType(t: T): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

---

Some general hints:

• Avoid asking multiple questions at once
• Avoid asking multiple questions about one of the answers to you previous question in the same posting.
• This probably gonna require some heavy editing...

Edit

I'll just try to answer all additional questions in more or less the same order as you've added them to your posting:

1. It works with holder.ElementType, because when you instantiate Client, the holder is known to be of type TypeHolder[Foo], therefore we know holder.ElementType = Foo.

2. It does not work with T#ElementType for T <: TypeHolder[_], because, as the existential in the signature says, T can be a TypeHolder forSome unspecified ElementType:

T <: TypeHolder[_$1] forSome { type _$1 }

T#ElementType 
  = (TypeHolder[_])#ElementType
  = (TypeHolder[_$1] forSome { type _$1 })#ElementType 
  = _$1

thus T#ElementType is set to some weird synthetic existential type _$1, and you get the error message that looks somewhat like this:

typeHolder.scala:6: error: type mismatch;
  found   : Main.foo.type (with underlying type Foo)
  required: _$1
  client.showElementType(foo)
                         ^

So, setting it to an existential type is completely useless, you will never be able to find a term that satisfies this weird type constraint. You can't even cast into this type by force, because this type doesn't even have a name by which it can be referenced anywhere in code.

To be honest: this seems like complete garbage. This whole projection shouldn't compile at all, why in the world would anyone want an existentially quantified type to escape from under its quantifier? This probably should be reported as a compiler issue.

3. The definition

class Client[T, H <: TypeHolder { type ElementType = T }]

works because it also keeps the type T explicit. If you replaced it by an existential

class Client[T, H <: TypeHolder { type ElementType = X forSome { type X }}]

then again every connection between T and TypeHolder would be lost, and it would fail for very much the same reason as T#ElementType above: you just can't replace the element type by some unknown existential and then hope to be able to pass Foo to it.

4. On "is it possible to define client use only one type parameter?" -- of, course, why not?

import scala.language.higherKinds
object Application extends App {
  private val foo = new Foo
  private val holder = new FooTypeHolder
  private val client = new Client(holder)
  client.showElementType(foo)
}

class Foo

trait TypeHolder {
  type ElementType
}

class FooTypeHolder extends TypeHolder {
  type ElementType = Foo
}

class Client[H <: TypeHolder](val holder: H) {
  def showElementType(t: H#ElementType): Unit = {
    println("show element type " + t.toString)
    println(t.getClass)
  }
}

Just don't add any type parameters to TypeHolder, so you don't have to erase them by existentials later.