Understanding breakdown of case classes - scala

Question

If I have case class defined as below
case class Calculator(brand: String, model: String)
How does it's companion object's unapply method would look like? What type of arguments would it take?
I am not able to emulate this by defining a class and then it's companion object by myself.
class abc (age:Int, name:String) {
}
object abc {
def apply(age:Int, name:String) = new abc(age, name)
def unapply(obj:abc) = Some("test")
}
abc(1, "aaaa")
res6: abc = abc#269f4bad
res6 match {
| case abc(1, "aaaa") => println("found")
| }
error: too many patterns for object abc offering String: expected 1, found 2
case abc(1, "aaaa") => println("found")
^
<console>:14: error: type mismatch;
found : Int(1)
required: String
case abc(1, "aaaa") => println("found")

Answer 1

You'll need to make age and name members of your class so that they are accessible after construction (can be done by making them vals), and then use them in unapply:
class abc (val age:Int, val name:String)
object abc {
def apply(age:Int, name:String) = new abc(age, name)
def unapply(candidate: abc) = Some((candidate.age, candidate.name))
}
Which would match correctly:
scala> new abc(2, "bbbb") match {
| case abc(1, "aaaa") => println("found 1")
| case abc(2, "bbbb") => println("found 2")
| case _ => println("not found")
| }
found 2

Answer 2

Tzach beat me to it..
Your error message btw. is because of the mismatch between the Option your unapply returns (which contains a single string) and the match in your case statement (with wants to match against a pair).
You could include a null check just to make sure (the compiler does, for case class companion objects):
class Abc(val age: Int, val name: String)
object Abc {
def unapply(obj: Abc): Option[(Int, String)] =
if (obj == null)
None
else
Some((obj.age, obj.name))
}
Shameless self-promotion: If you're interested in more details of pattern matching, you might find my little presentation "Everything you always wanted to know about pattern matching" useful.

Answer 3

If you want to create a custom class which has a unapply method and want to use the Extractor Pattern with it, the following rules should apply:
The return type of an unapply should be chosen as follows:
If it is just a test, return a Boolean. For instance case even()
If it returns a single sub-value of type T, return an Option[T]
If you want to return several sub-values T1,...,Tn, group them in an optional
tuple Option[(T1,...,Tn)].
Generally, this means that for you example all that needs to be done with the unapply method is the third option, which returns a tuple of values. Following that, unlike the case class which automatically creates immutable fields for you, you'll need to add the val annotation to you class declaration.
class abc (val age: Int, val name: String)
And:
def unapply(obj: abc): Option[(Int, String)] = Some((obj.age, obj.name))