39

I am learning scala and tried following form Scala Cookbook:

trait Animal
trait FurryAnimal extends Animal
case class Dog(name:String) extends Animal
case class Cat(name:String) extends Animal

Now when I did following as :

val x = Array(Dog("Fido"),Cat("Felix"))

it show result as :

x:Array[Product with Serializable with Animal] = Array(Dog(Fido),Cat(Felix))

Although I know that a case class is mixed in with Product trait

What I am not getting is : Product with Serializable with Animal

As per my understanding Product has something to do with Pattern matching

I did google it but didn't get anything.Please Help to get me the concept in detail.

Thanks

Yuval Itzchakov
  • 146,575
  • 32
  • 257
  • 321
optional
  • 3,260
  • 5
  • 26
  • 47
  • Hey its a heterogeneous Array and both the Elements extends Animal, hence with Animal. If you put both these case classes inside another case class and then add that case class to the array. you would get the array of the case class. I was myself searching for a good read on this Product with Serializable back some time.. But didn't found one. Maybe someone may clear our thoughts.! – Shivansh Apr 10 '16 at 05:37
  • 1
    http://underscore.io/blog/posts/2015/06/04/more-on-sealed.html – som-snytt Apr 10 '16 at 06:00
  • also https://github.com/scala/scala-abide/issues/41 – som-snytt Apr 10 '16 at 06:03
  • @som-snytt : Yes I saw that but my question is why compiler is doing so, Is there any specific reason .As far as my understanding is that the signature is doing something with Pattern Matching(I may be wrong here),But I am not clear. – optional Apr 10 '16 at 06:27

3 Answers3

64

This is an expected behavior because of how case class works. case class automatically extends two traits, namely Product and Serializable.

Product trait is extended as case class is an algebraic data type with product type.

Serializable trait is extended so that case class can be treated as a pure data - i.e capable of being serialized.

Unlike case class Dog and Cat, your trait Animal does not extend Product or Serializable. Hence the type signature you see.

When you declare something like Array(Dog(""), Cat("")), scalac needs to infer single top type that can represent all the elements of given array.

That's why the inferred type is Product with Serializable with Animal as Animal did not extend Product nor Serializable while the case class did implicitly.

To work around this inference, you can either make type explicit by Animal or make Animal extend Product and Serializable.

trait Animal extends Product with Serializable

case class Dog(name: String) extends Animal
case class Cat(name: String) extends Animal

Array(Dog(""), Cat("")) // Array[Animal] = Array(Dog(), Cat())
Daniel Shin
  • 5,086
  • 2
  • 30
  • 53
15

All case classes in Scala posses a few properties:

  1. They will automatically extend the Product trait and a default implementation will be provided for them, as they can be viewed as a Cartesian Product of N records.
  2. They will extend Serializable as they are serializable out of the box (as a design choice).
  3. They will have an implementation of hashCode and equals provided by the compiler, which aids with pattern matching
  4. They will provide apply and unapply methods, for composition and decomposition of the type.

Case classes are also Scala's way of expressing an Algebraic Data Type, more specifically a Product Type. Tuples are also a product type, and as so they also extend the Product trait.

When you use two case classes with a common trait, the scala's compiler will use it's type inference algorithm to attempt to find the least upper bound (LUB) for the T type of the Array. Since both case classes extend Product and Serializable through the compiler, and the trait does not, it will during the search and apply it to the final calculated type.

If you want to avoid seeing that, you can have your trait explicitly extend those traits:

sealed trait Animal extends Product with Serializable

More on this topic can be found here

Yuval Itzchakov
  • 146,575
  • 32
  • 257
  • 321
0

All case classes automatically extend Product and Serializable. It looks ugly ? yes. Basically ,Product can be viewed as heterogeneous collections. All Product classes viz. (Product1 , Product2 ...) extends Product which contains some common methods to use like productArity , productElement etc.

Like Case classes other types that extends Product are List,Tuple etc

From my scala worksheet,

  val product : Product = (10,"String",3)         //> product  : Product = (10,String,3)
  product.productArity                            //> res0: Int = 3
  product.productElement(0)                       //> res1: Any = 10
  product.productElement(1)                       //> res2: Any = String
  product.productElement(2)                       //> res3: Any = 3

case class ProductCase(age:Int,name:String,ISBN:Int)
  ProductCase(23,"som",5465473).productArity      //> res4: Int = 3

For details look here.

Community
  • 1
  • 1
Som Bhattacharyya
  • 3,972
  • 35
  • 54