How to access a class's type parameter in Scala

Question

I have a type-parameterized abstract class that contains a val and a method that both use its type parameter

abstract class Foo[T](val state: T){
  def foo(arg: T){
    ...
  }
}

I also have a class that extends this abstract class and provides the type parameter and a value for state

class Bar(myNumber: Int) extends Foo[Int](myNumber){
   ...
}

I pass an instance of Bar to another class that accepts any subclass of Foo, and I would like to call the method foo on state, but I'm running into some trouble:

class Baz(val f: Foo[_]){
    f.foo(f.state)
}

This gives the error:

<console>:8: error: type mismatch;
 found   : Baz.this.f.state.type (with underlying type _$1)
 required: _$1
         f.foo(f.state)

Is there any way to give Baz knowledge of Bar's type parameter so that it compiles correctly? Or is that even what I want to do?

Edit

To clarify, I have many classes similar to Bar that extend Foo and provide their own type parameter, state, and implementation of foo. I would like users of my library to be able to pass any of them to Baz without worrying about the type parameter T since its just an implementation detail of each subclass of Foo.

So I would strongly prefer not to do this:

class Baz[T](val f: Foo[T]){
  f.foo(f.state)
}

Existentials considered harmful. That thread covers why, and different solutions that could be used. — ggovan
– ggovan, Commented May 25, 2014 at 19:07
possible duplicate of Can an existentially quantified type variable be forced to have only a single type? — ggovan
– ggovan, Commented May 25, 2014 at 19:07
That question is different because the asker specifies a type T and wants the existential type to be a superclass of it. In my question I want to ignore it entirely. Additionally I tried their answer and it didn't work. — DLaw
– DLaw, Commented May 25, 2014 at 21:15

Didier Dupont · Accepted Answer · 2014-05-25 19:22:44Z

2

You just need a

def fooOnState[T](ft: Foo[T]) = ft.foo(ft.state)

calling it with a Foo[_] is ok.

Still, existentials are best avoided most of the time, but it depends on your real code.

answered May 25, 2014 at 19:22

Didier Dupont

29.6k7 gold badges73 silver badges90 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

DLaw Over a year ago

This would work, but then how would I access the T that I need to call fooOnState? I have many different subclasses of Foo each with their own T, etc...

Didier Dupont Over a year ago

Not sure I understand, you may call fooOnState passing it a Foo[_], in your code, just call fooOnState(f) rather than f.foo(f.state) you are not required to know T for that.

DLaw Over a year ago

My apologies, I didn't know you could omit that type parameter when calling. Accepted!

Ben Kovitz · Accepted Answer · 2014-05-25 23:03:26Z

0

Replacing the type parameter with a "type member" in a trait would let you write generic code that works for all state types, at the expense of a little verbosity to specify the type member in each subclass:

trait Foo {
  type StateT  // this is the "type member"
  val state: StateT
  def foo(arg: StateT): Unit
}

class Bar(myNumber: Int) extends Foo {
  type StateT = Int     // this is the verbose part
  override val state = myNumber  // this, too
  override def foo(arg: StateT) { /* something specific here */ }
}

class Baz(val f: Foo) {
  f.foo(f.state)  // generic code, works on any Foo subclass
}

edited May 25, 2014 at 23:03

answered May 25, 2014 at 22:50

Ben Kovitz

5,1202 gold badges24 silver badges57 bronze badges

Collectives™ on Stack Overflow

How to access a class's type parameter in Scala

2 Answers 2

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related