Question

I think I’d like to be able to do something like the following (clearly garbage) code illustrates:

// Clearly nonsensical
case class Example(a: String) {
    def a: Array[Byte] = a.getBytes
}

The gist of it is that I want to write an accessor method for a case class that is named identically to one of its constructor arguments.

I’m using a JSON serialization library called Jerkson that, according to my understanding, will behave in the way I want it to if I define a class in this manner. I’m basing that assumption on this code. Currently, I’m stumped.

If this isn’t possible, could anyone offer some insight on what the Jerkson library code is attempting to do?

Answer 1

Scala automatically creates a method with the same name as any val declared in a class (including the fields of case classes) to support a concept called referential transparency. This is also why you can override a def with a val. If you’re still skeptical, you can test it yourself like this:

First, create a Scala file with a single case class.

// MyCase.scala
case class MyCase(myField1: Int, myField2: String)

Now, compile the file with scalac. This should result in two classes. For the example above I get MyCase.class (representing the actual case class type) and MyCase$.class (representing the auto-generated companion object for the case class).

$ scalac MyCase.scala 
$ ls
MyCase$.class MyCase.class  MyCase.scala

Now you can examine the resulting .class file corresponding to the case class you declared using javap. (javap standard tool for examining Java bytecode—it’s distributed along with javac in the JDK.)

$ javap -private MyCase
Compiled from "MyCase.scala"
public class MyCase extends java.lang.Object implements scala.Product,scala.Serializable{
    private final int myField1;
    private final java.lang.String myField2;
    public static final scala.Function1 tupled();
    public static final scala.Function1 curry();
    public static final scala.Function1 curried();
    public scala.collection.Iterator productIterator();
    public scala.collection.Iterator productElements();
    public int myField1();
    public java.lang.String myField2();
    public MyCase copy(int, java.lang.String);
    public java.lang.String copy$default$2();
    public int copy$default$1();
    public int hashCode();
    public java.lang.String toString();
    public boolean equals(java.lang.Object);
    public java.lang.String productPrefix();
    public int productArity();
    public java.lang.Object productElement(int);
    public boolean canEqual(java.lang.Object);
    private final boolean gd1$1(int, java.lang.String);
    public MyCase(int, java.lang.String);
}

Notice how the resulting class has both a private final int myField1 and a public int myField1() corresponding to the case class’s myField1 field. The same for myField2.

On the JVM method return types are not part of the method signature. This means that if two methods have the same name and the same argument types then they’re considered to be conflicting method declarations. This means you can’t declare the def a: Array[Byte] in your example because val a: String already exists, also taking no arguments.

Update:

I just looked at the library code and according to the examples the case classes should just work. There is a note in the README saying that parsing case classes does not work in the REPL. Could that be your problem? If not, you should really post the error you’re getting. Edit: Never mind, I see the error you’re talking about in your link to your other post. If I think of a response to that problem I’ll post it over there.