Fixed type parameter in alternative constructor

Question

Can this be done?

final case class C[A] (v: A) {
  def this() = this(true)
}

When constructed with given constructor, C is automatically a C[Boolean]. This version does not compile but it feels like it should be doable somehow, especially as the following seems to work:

final case class C[A] (v: A = true)

I want some Java interoperability, so I try to avoid default values. I think that I can achieve this by using factory methods in a companion object, but can it be done directly? As C is a case class, factory methods are a bit messy IMHO.

score 3 · Answer 1 · answered Feb 20 '14 at 16:15

3

What is wrong with

object C{
  def apply() = C(true)
}

such that you use the companion object? In Java, this would be, C$.apply() no?

answered Feb 20 '14 at 16:15

wheaties

35,646
15
94
131

Besides the quite ugly Java call (IMHO), such a method for a case class seems to imply that an associated unapply() method should also be defined (for Pattern Matching). Is this a standard Scala code style? – scand1sk Feb 20 '14 at 16:19
1

@scand1sk You don't have to define an `unapply` when you define an `apply`. Doubly so for a case class. – wheaties Feb 20 '14 at 16:24

James_pic · Accepted Answer · 2014-02-20T16:44:10.270

I suspect factory methods in the companion object are the best you can do (as wheaties has suggested). We can make it compile, but at the expense of sillyness down the line. For example:

final case class C[A] (v: A) {
  def this() = this("Hello".asInstanceOf[A]) // Compiles, thanks to type erasure
}

val c = new C[Int]() // Still compiles, despite the fact that "Hello" is not an Int
println(c) // C(Hello)
c.v + 1 // Compiles, but throws a ClassCastException at run-time

The basic problem is that type parameters are specified at the class level, not the constructor level, so all constructors have to use the same type parameters. On the other hand, methods can take type parameters, so factory methods are no problem. Also, Java Interop for factory methods isn't all that bad. You could do something like:

// C.scala
final case class C[A] (v: A) 
object C {
    def apply(): C[Boolean] = C(true)
}

// Test.java
public class Test {
    public C c = C.apply();
}

The scala compiler creates static methods to simplify Java interop, so you don't usually need to mess around with C$.

Fixed type parameter in alternative constructor

2 Answers2