How to create a Scala function that can parametrically create instances of sub-types of some type

Question

Sorry I'm not very familiar with Scala, but I'm curious if this is possible and haven't been able to figure out how.

Basically, I want to create some convenience initializers that can generate a random sample of data (in this case a grid). The grid will always be filled with instances of a particular type (in this case a Location). But in different cases I might want grids filled with different subtypes of Location, e.g. Farm or City.

In Python, this would be trivial:

def fillCollection(klass, size):
    return [klass() for _ in range(size)]

class City: pass

cities = fillCollection(City, 10)

I tried to do something similar in Scala but it does not work:

def fillGrid[T <: Location](size): Vector[T] = {
    Vector.fill[T](size, size) {
        T()
    }
}

The compiler just says "not found: value T"

So, it it possible to approximate the above Python code in Scala? If not, what's the recommended way to handle this kind of situation? I could write an initializer for each subtype, but in my real code there's a decent amount of boilerplate overlap between them so I'd like to share code if possible.

The best workaround I've come up with so far is to pass a closure into the initializer (which seems to be how the fill method on Vectors already works), e.g.:

  def fillGrid[T <: Location](withElem: => T, size: Int = 100): Vector[T] = {
    Vector.fill[T](n1 = size, n2 = size)(withElem)
  }

That's not a huge inconvenience, but it makes me curious why Scala doesn't support the "simpler" Python-style construct (if it in fact doesn't). I sort of get why having a "fully generic" initializer could cause trouble, but in this case I can't see what the harm would be generically initializing instances that are all known to be subtypes of a given parent type.

Ethan · Accepted Answer · 2018-11-02 15:55:51Z

1

You are correct, in that what you have is probably the simplest option. The reason Scala can't do things the pythonic way is because the type system is much stronger, and it has to contend with type erasure. Scala can not guarantee at compile time that any subclass of Location has a particular constructor, and it will only allow you to do things that it can guarantee will conform to the types (unless you do tricky things with reflection).

If you want to clean it up a little bit, you can make it work more like python by using implicits.

implicit def emptyFarm(): Farm = new Farm
implicit def emptyCity(): City = new City

def fillGrid[T <: Location](size: Int = 100)(implicit withElem: () => T): Vector[Vector[T]] = {
  Vector.fill[T](n1 = size, n2 = size)(withElem())
}

fillGrid[farm](3)

To make this more usable in a library, it's common to put the implicits in a companion object of Location, so they can all be brought into scope where appropriate.

sealed trait Location
...
object Location
{
  implicit def emptyFarm...
  implicit def emptyCity...
}
...
import Location._
fillGrid[Farm](3)

edited Nov 2, 2018 at 15:55

answered Nov 1, 2018 at 19:06

Ethan

8414 silver badges12 bronze badges

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

3 Comments

rogueleaderr Over a year ago

Thanks. That answer makes sense and implicits seem like a clean strategy. I am curious about the "compiler can't ensure a specific constructor thing" -- if e.g. Location has a zero argument constructor, is it possible that sub-types of Location do not have a zero argument constructor (i.e. can subtypes somehow not have access to parents' methods?). Otherwise it would seem that the T <: Location requirement should assure the presence of the necessary constructor iff `Location has it.

Ethan Over a year ago

Your biggest enemy here is type erasure. Basically, the JVM will automatically treat everything passed in as the upper type bound, in this case Location. Unfortunately, that means that you don't know the actual class that was supplied, just that it was some subtype of Location. Scala has a pretty nice reflection library to get around this when you absolutely need to, but it's best to avoid it, because you lose a lot of type safety.

Tim Over a year ago

There are a number of problems with this code, including the wrong return type (should be Vector[Vector[T]]), passing a function to fill not a value (should be withElem()), and expecting an implicit method to match an implicit val. If possible it is best to provide sample code that compiles and works.

Luis Miguel Mejía Suárez · Accepted Answer · 2018-11-01 16:19:58Z

1

You can use reflection to accomplish what you want...

This is a simple example that will only work if all your subclasses have a zero args constructor.

sealed trait Location
class Farm extends Location
class City extends Location

def fillGrid[T <: Location](size: Int)(implicit TTag: scala.reflect.ClassTag[T]): Vector[Vector[T]] = {
  val TClass = TTag.runtimeClass
  Vector.fill[T](size, size) { TClass.newInstance().asInstanceOf[T] }
}

However, I have never been a fan of runtime reflection, and I hope there could be another way.

answered Nov 1, 2018 at 16:19

Luis Miguel Mejía Suárez

23k4 gold badges31 silver badges50 bronze badges

Comments

Joe K · Accepted Answer · 2018-11-01 18:31:09Z

1

Scala cannot do this kind of thing directly because it's not type safe. It will not work if you pass a class without a zero-argument constructor. The Python version throws an error at runtime if you try to do this.

The closure is probably the best way to go.

answered Nov 1, 2018 at 18:31

Joe K

18.5k2 gold badges42 silver badges61 bronze badges

Collectives™ on Stack Overflow

How to create a Scala function that can parametrically create instances of sub-types of some type

3 Answers 3

3 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related