views:

269

answers:

2

Why were the case classes without a parameter list deprecated from Scala? And why does compiler suggest to use () as parameter list instead?

EDIT :

Someone please answer my second question... :|

+2  A: 

Without parameters, every instance of the case class is indistinguishable and hence is essentially a constant. Use an object for that case.

Randall Schulz
+11  A: 

It is really easy to accidentally use a no-arg case class incorrectly as a pattern.

scala> case class Foo                                             
warning: there were deprecation warnings; re-run with -deprecation for details
defined class Foo

scala> (new Foo: Any) match { case Foo => true; case _ => false } 
res10: Boolean = false

Instead of:

scala> (new Foo: Any) match { case _: Foo => true; case _ => false } 
res11: Boolean = true

Or better:

scala> case object Bar                                               
defined module Bar

scala> (Bar: Any) match { case Bar => true; case _ => false }        
res12: Boolean = true

UPDATE Hopefully the transcript below will demonstrate why an empty parameter list is preferred to the deprecated missing parameter list.

scala> case class Foo() // Using an empty parameter list rather than zero parameter lists.
defined class Foo

scala> Foo // Access the companion object Foo
res0: Foo.type = <function0>

scala> Foo() // Call Foo.apply() to construct an instance of class Foo
res1: Foo = Foo()

scala> case class Bar
warning: there were deprecation warnings; re-run with -deprecation for details
defined class Bar

scala> Bar // You may expect this to construct a new instance of class Bar, but instead
           // it references the companion object Bar 
res2: Bar.type = <function0>

scala> Bar() // This calls Bar.apply(), but is not symmetrical with the class definition.
res3: Bar = Bar()

scala> Bar.apply // Another way to call Bar.apply
res4: Bar = Bar()

A case object would usually still be preferred over an empty parameter list.

retronym
Instead of `case _: Foo` you can write `case Foo()`.
sepp2k
I still don't get it. Why would I expect `Bar` construct to create a new instance of class `Bar`?
missingfaktor
**"Bar() // This calls Bar.apply(), but is not symmetrical with the class definition."** -- This argument applies to normal (non case) classes as well. Then why doesn't compiler show warning when I define such a class without parameter list? (for instance, `class Bar`)
missingfaktor
Normal class instantiation with `new` works without an argument list. For example: `class Bar; new Bar` is symmetrical. A case class generates a companion object with an apply and unapply method so construction can be done without `new`.
retronym