What is the difference between Scala s case class and class

Question

I searched in Google to find the differences between a case class and a class  Everyone mentions that when you want to do pattern matching on the class  use case class  Otherwise use classes and also mentioning some extra perks like equals and hash code overriding  But are these the only reasons why one should use a case class instead of class    I guess there should be some very important reason for this feature in Scala  What is the explanation or is there a resource to learn more about the Scala case classes from

User · Answer

To have the ultimate understanding of what is a case class:

let's assume the following case class definition:

case class Foo(foo:String, bar: Int)

and then do the following in the terminal:

$ scalac -print src/main/scala/Foo.scala

Scala 2.12.8 will output:

...
case class Foo extends Object with Product with Serializable {

  <caseaccessor> <paramaccessor> private[this] val foo: String = _;

  <stable> <caseaccessor> <accessor> <paramaccessor> def foo(): String = Foo.this.foo;

  <caseaccessor> <paramaccessor> private[this] val bar: Int = _;

  <stable> <caseaccessor> <accessor> <paramaccessor> def bar(): Int = Foo.this.bar;

  <synthetic> def copy(foo: String, bar: Int): Foo = new Foo(foo, bar);

  <synthetic> def copy$default$1(): String = Foo.this.foo();

  <synthetic> def copy$default$2(): Int = Foo.this.bar();

  override <synthetic> def productPrefix(): String = "Foo";

  <synthetic> def productArity(): Int = 2;

  <synthetic> def productElement(x$1: Int): Object = {
    case <synthetic> val x1: Int = x$1;
        (x1: Int) match {
            case 0 => Foo.this.foo()
            case 1 => scala.Int.box(Foo.this.bar())
            case _ => throw new IndexOutOfBoundsException(scala.Int.box(x$1).toString())
        }
  };

  override <synthetic> def productIterator(): Iterator = scala.runtime.ScalaRunTime.typedProductIterator(Foo.this);

  <synthetic> def canEqual(x$1: Object): Boolean = x$1.$isInstanceOf[Foo]();

  override <synthetic> def hashCode(): Int = {
     <synthetic> var acc: Int = -889275714;
     acc = scala.runtime.Statics.mix(acc, scala.runtime.Statics.anyHash(Foo.this.foo()));
     acc = scala.runtime.Statics.mix(acc, Foo.this.bar());
     scala.runtime.Statics.finalizeHash(acc, 2)
  };

  override <synthetic> def toString(): String = scala.runtime.ScalaRunTime._toString(Foo.this);

  override <synthetic> def equals(x$1: Object): Boolean = Foo.this.eq(x$1).||({
      case <synthetic> val x1: Object = x$1;
        case5(){
          if (x1.$isInstanceOf[Foo]())
            matchEnd4(true)
          else
            case6()
        };
        case6(){
          matchEnd4(false)
        };
        matchEnd4(x: Boolean){
          x
        }
    }.&&({
      <synthetic> val Foo$1: Foo = x$1.$asInstanceOf[Foo]();
      Foo.this.foo().==(Foo$1.foo()).&&(Foo.this.bar().==(Foo$1.bar())).&&(Foo$1.canEqual(Foo.this))
  }));

  def <init>(foo: String, bar: Int): Foo = {
    Foo.this.foo = foo;
    Foo.this.bar = bar;
    Foo.super.<init>();
    Foo.super./*Product*/$init$();
    ()
  }
};

<synthetic> object Foo extends scala.runtime.AbstractFunction2 with Serializable {

  final override <synthetic> def toString(): String = "Foo";

  case <synthetic> def apply(foo: String, bar: Int): Foo = new Foo(foo, bar);

  case <synthetic> def unapply(x$0: Foo): Option =
     if (x$0.==(null))
        scala.None
     else
        new Some(new Tuple2(x$0.foo(), scala.Int.box(x$0.bar())));

  <synthetic> private def readResolve(): Object = Foo;

  case <synthetic> <bridge> <artifact> def apply(v1: Object, v2: Object): Object = Foo.this.apply(v1.$asInstanceOf[String](), scala.Int.unbox(v2));

  def <init>(): Foo.type = {
    Foo.super.<init>();
    ()
  }
}
...

As we can see Scala compiler produces a regular class Foo and companion-object Foo.

Let's go through the compiled class and comment on what we have got:

the internal state of the Foo class, immutable:

val foo: String
val bar: Int

getters:

def foo(): String
def bar(): Int

copy methods:

def copy(foo: String, bar: Int): Foo
def copy$default$1(): String
def copy$default$2(): Int

implementing scala.Product trait:

override def productPrefix(): String
def productArity(): Int
def productElement(x$1: Int): Object
override def productIterator(): Iterator

implementing scala.Equals trait for make case class instances comparable for equality by ==:

def canEqual(x$1: Object): Boolean
override def equals(x$1: Object): Boolean

overriding java.lang.Object.hashCode for obeying the equals-hashcode contract:

override <synthetic> def hashCode(): Int

overriding java.lang.Object.toString :

override def toString(): String

constructor for instantiation by new keyword:

def <init>(foo: String, bar: Int): Foo

Object Foo: - method apply for instantiation without new keyword:

case <synthetic> def apply(foo: String, bar: Int): Foo = new Foo(foo, bar);

extractor method unupply for using case class Foo in pattern matching:

case <synthetic> def unapply(x$0: Foo): Option

method to protect object as singleton from deserialization for not letting produce one more instance:

<synthetic> private def readResolve(): Object = Foo;

object Foo extends scala.runtime.AbstractFunction2 for doing such trick:

scala> case class Foo(foo:String, bar: Int)
defined class Foo

scala> Foo.tupled
res1: ((String, Int)) => Foo = scala.Function2$$Lambda$224/1935637221@9ab310b

tupled from object returns a funtion to create a new Foo by applying a tuple of 2 elements.

So case class is just syntactic sugar.

User · Answer

Case classes can be seen as plain and immutable data-holding objects that should exclusively depend on their constructor arguments   This functional concept allows us to   use a compact initialization syntax  Node 1  Leaf 2   None    decompose them using pattern matching have equality comparisons implicitly defined    In combination with inheritance  case classes are used to mimic algebraic datatypes   If an object performs stateful computations on the inside or exhibits other kinds of complex behaviour  it should be an ordinary class

User · Answer

Technically  there is no difference between a class and a case class -- even if the compiler does optimize some stuff when using case classes  However  a case class is used to do away with boiler plate for a specific pattern  which is implementing algebraic data types   A very simple example of such types are trees  A binary tree  for instance  can be implemented like this   sealed abstract class Tree case class Node left  Tree  right  Tree  extends Tree case class Leaf A  value  A  extends Tree case object EmptyLeaf extends Tree   That enable us to do the following      DSL-like assignment  val treeA   Node EmptyLeaf  Leaf 5   val treeB   Node Node Leaf 2   Leaf 3    Leaf 5       On Scala 2 8  modification through cloning  val treeC   treeA copy left   treeB left      Pretty printing  println  Tree A    treeA  println  Tree B    treeB  println  Tree C    treeC      Comparison  println  Tree A    Tree B   s  format  treeA    treeB  toString  println  Tree B    Tree C   s  format  treeB    treeC  toString      Pattern matching  treeA match     case Node EmptyLeaf  right    gt  println  Can be reduced to   right    case Node left  EmptyLeaf    gt  println  Can be reduced to   left    case     gt  println treeA   cannot be reduced         Pattern matches can be safely done  because the compiler warns about    non-exaustive matches  def checkTree t  Tree    t match     case Node EmptyLeaf  Node left  right     gt       case Node EmptyLeaf  Leaf el     gt    case Node Node left  right   EmptyLeaf    gt    case Node Leaf el   EmptyLeaf    gt    case Node Node l1  r1   Node l2  r2     gt    case Node Leaf e1   Leaf e2     gt    case Node Node left  right   Leaf el     gt    case Node Leaf el   Node left  right     gt       case Node EmptyLeaf  EmptyLeaf    gt    case Leaf el    gt    case EmptyLeaf   gt      Note that trees construct and deconstruct  through pattern match  with the same syntax  which is also exactly how they are printed  minus spaces    And they can also be used with hash maps or sets  since they have a valid  stable hashCode

User · Answer

No one mentioned that case classes are also instances of Product and thus inherit these methods   def productElement n  Int   Any def productArity  Int def productIterator  Iterator Any    where the productArity returns the number of class parameters  productElement i  returns the ith parameter  and productIterator allows iterating through them

User · Answer

Unlike classes  case classes are just used to hold data   Case classes are flexible for data-centric applications  which means you can define data fields in case class and define business logic in a companion object  In this way  you are separating the data from the business logic   With the copy method  you can inherit any or all required properties from the source and can change them as you like

User · Answer

Apart from what people have already said  there are some more basic differences between class and case class  1 Case Class doesn t need explicit new  while class need to be called with new  val classInst   new MyClass          For classes val classInst   MyClass              For case class   2 By Default constructors parameters are private in class   while its public in case class     For class class MyClass x Int      val classInst   new MyClass 10   classInst x      FAILURE   can t access     For caseClass case class MyClass x Int      val classInst   MyClass 10   classInst x      SUCCESS   3 case class compare themselves by value     case Class class MyClass x Int       val classInst   new MyClass 10  val classInst2   new MyClass 10   classInst    classInst2    FALSE     For Case Class case class MyClass x Int       val classInst   MyClass 10  val classInst2   MyClass 10   classInst    classInst2    TRUE

User · Answer

Case classes define a compagnon object with apply and unapply methods Case classes extends Serializable  Case classes define equals hashCode and copy methods All attributes of the constructor are val  syntactic sugar

User · Answer

The case class construct in Scala can also be seen as a convenience to remove some boilerplate   When constructing a case class Scala gives you the following    It creates a class as well as its companion object Its companion object implements the apply method that you are able to use as a factory method  You get the syntactic sugar advantage of not having to use the new keyword       Because the class is immutable you get accessors  which are just the variables  or properties  of the class but no mutators  so no ability to change the variables   The constructor parameters are automatically available to you as public read only fields  Much nicer to use than Java bean construct     You also get hashCode  equals  and toString methods by default and the equals method compares an object structurally  A copy method is generated to be able to clone an object  with some fields having new values provided to the method      The biggest advantage as has been mentioned previously is the fact that you can pattern match on case classes  The reason for this is because you get the unapply method which lets you deconstruct a case class to extract its fields          In essence what you are getting from Scala when creating a case class  or a case object if your class takes no arguments  is a  singleton object which serves the purpose as a factory and as an extractor

User · Answer

A case class is a class that may be used with the match case statement   def isIdentityFun term  Term   Boolean   term match     case Fun x  Var y   if x    y   gt  true   case     gt  false     You see that case is followed by an instance of class Fun whose 2nd parameter is a Var  This is a very nice and powerful syntax  but it cannot work with instances of any class  therefore there are some restrictions for case classes  And if these restrictions are obeyed  it is possible to automatically define hashcode and equals   The vague phrase  a recursive decomposition mechanism via pattern matching  means just  it works with case    Indeed  the instance followed by match is compared to  matched against  the instance that follows case  Scala has to decompose them both  and has to recursively decompose what they are made of    What case classes are useful for  The Wikipedia article about Algebraic Data Types gives two good classical examples  lists and trees  Support for algebraic data types  including knowing how to compare them  is a must for any modern functional language   What case classes are not useful for  Some objects have state  the code like connection setConnectTimeout connectTimeout  is not for case classes   And now you can read A Tour of Scala  Case Classes

User · Answer

Case classes can be pattern matched Case classes automatically define hashcode and equals Case classes automatically define getter methods for the constructor arguments     You already mentioned all but the last one    Those are the only differences to regular classes

User · Answer

Nobody mentioned that case class companion object has tupled defention  which has a type   case class Person name  String  age  Int    Person tupled is def tupled    String  Int     gt  Person   The only use case I can find is when you need to construct case class from tuple  example   val bobAsTuple     bob   14  val bob    Person apply    tupled bobAsTuple    bob  Person   Person bob 14    You can do the same  without tupled  by creating object directly  but if your datasets expressed as list of tuple with arity 20 tuple with 20 elements   may be using tupled is your choise

User · Answer

No one mentioned that case classes have val constructor parameters yet this is also the default for regular classes  which I think is an inconsistency in the design of Scala   Dario implied such where he noted they are  immutable    Note you can override the default by prepending the each constructor argument with var for case classes  However  making case classes mutable causes their equals and hashCode methods to be time variant   91 1   sepp2k already mentioned that case classes automatically generate equals and hashCode methods   Also no one mentioned that case classes automatically create a companion object with the same name as the class  which contains apply and unapply methods  The apply method enables constructing instances without prepending with new  The unapply extractor method enables the pattern matching that others mentioned   Also the compiler optimizes the speed of match-case pattern matching for case classes  91 2      91 1  Case Classes Are Cool    91 2  Case Classes and Extractors  pg 15

User · Answer

Class   scala gt  class Animal name String  defined class Animal  scala gt  val an1   new Animal  Padddington   an1  Animal   Animal 748860cc  scala gt  an1 name  lt console gt  14  error  value name is not a member of Animal        an1 name                But if we use same code but use case class   scala gt  case class Animal name String  defined class Animal  scala gt  val an2   new Animal  Paddington   an2  Animal   Animal Paddington   scala gt  an2 name res12  String   Paddington   scala gt  an2    Animal  fred   res14  Boolean   false  scala gt  an2    Animal  Paddington   res15  Boolean   true   Person class   scala gt  case class Person first String last String age Int  defined class Person  scala gt  val harry   new Person  Harry   Potter  30  harry  Person   Person Harry Potter 30   scala gt  harry res16  Person   Person Harry Potter 30  scala gt  harry first    Saily   lt console gt  14  error  reassignment to val        harry first    Saily                       scala gt val saily    harry copy first  Saily   res17  Person   Person Saily Potter 30   scala gt  harry copy age   harry age 1  res18  Person   Person Harry Potter 31    Pattern Matching   scala gt  harry match          case Person  Harry    age    gt  println age         case     gt  println  no match            30  scala gt  res17 match          case Person  Harry    age    gt  println age         case     gt  println  no match            no match   object  singleton   scala gt  case class Person first  String last String age Int  defined class Person  scala gt  object Fred extends Person  Fred   Jones  22  defined object Fred

User · Answer

According to Scala s documentation       Case classes are just regular classes that are          Immutable by default   Decomposable through pattern matching   Compared by structural equality instead of by reference   Succinct to instantiate and operate on      Another feature of the case keyword is the compiler automatically generates several methods for us  including the familiar toString  equals  and hashCode methods in Java

User · Answer

Some of the key features of case classes are listed below   case classes are immutable  You can instantiate case classes without new keyword  case classes can be compared by value   Sample scala code on scala fiddle  taken from the scala docs   https   scalafiddle io sf 34XEQyE 0

User · Answer

I think overall all the answers have given a semantic explanation about classes and case classes  This could be very much relevant  but every newbie in scala should know what happens when you create a case class  I have written this answer  which explains case class in a nutshell    Every programmer should know that if they are using any pre-built functions  then they are writing a comparatively less code  which is enabling them by giving the power to write most optimized code  but power comes with great responsibilities  So  use prebuilt functions with very cautions   Some developers avoid writing case classes due to additional 20 methods  which you can see by disassembling class file   Please refer this link if you want to check all the methods inside a case class

[scala] What is the difference between Scala's case class and class?

Examples related to scala

Examples related to functional-programming

Examples related to case-class