case-class

In Scala 2.8 is there a way to overload constructors of a case class? If yes, please put a snippet to explain, if not, please explain why? Overloading constructors isn't special for case classes: case class Foo(bar: Int, baz: Int) { def this(bar: Int) = this(bar, 0) } new Foo(1, 2) new Foo(1) However, you may like to also overload the apply method in the companion object, which is called when you omit new . object Foo { def apply(bar: Int) = new Foo(bar) } Foo(1, 2) Foo(1) In Scala 2.8, named and default parameters can often be used instead of overloading. case class Baz(bar: Int, baz: Int = 0

I'm trying to use a covariant type parameter inside a trait to construct a case-class like so: trait MyTrait[+T] { private case class MyClass(c: T) } compiler says: error: covariant type T occurs in contravariant position in type T of value c I then tried the following but it also didn't work: trait MyTrait[+T] { private case class MyClass[U <: T](c: U) } the error this time is: error: covariant type T occurs in contravariant position in type >: Nothing <: T of type U Could somebody explain why the T is in a covariant position here and suggest a solution for this problem? Thx! This is a

While looking for something else, quite out of mere coincidence I stumbled upon few comments about how diabolical case class inheritance is. There was this thing called ProductN , wretches and kings, elves and wizards and how some kind of a very desirable property is lost with case classes inheritance. So what is so wrong with case class inheritance ? One word: equality case classes come with a supplied implementation of equals and hashCode . The equivalence relation, known as equals works like this (i.e. must have the following properties): For all x ; x equals x is true (reflexive) For x , y

Let's say that I have a lot of similar data classes. Here's an example class User which is defined as follows: case class User (name: String, age: Int, posts: List[String]) { val numPosts: Int = posts.length ... def foo = "bar" ... } I am interested in automatically creating a method ( at compile time ) that returns a Map in a way that each field name is mapped to its value when it is called in runtime. For the example above, let's say that my method is called toMap : val myUser = User("Foo", 25, List("Lorem", "Ipsum")) myUser.toMap should return Map("name" -> "Foo", "age" -> 25, "posts" ->

Having a trait trait Persisted { def id: Long } how do I implement a method that accepts an instance of any case class and returns its copy with the trait mixed in? The signature of the method looks like: def toPersisted[T](instance: T, id: Long): T with Persisted Eugene Burmako This can be done with macros (that are officially a part of Scala since 2.10.0-M3). Here's a gist example of what you are looking for . 1) My macro generates a local class that inherits from the provided case class and Persisted, much like new T with Persisted would do. Then it caches its argument (to prevent multiple