unapply

I'd like an extractor to implicitly convert its parameters, but it doesn't seem to work. Consider this very simple case: case class MyString(s: String) {} implicit def string2mystring(x: String): MyString = new MyString(x) implicit def mystring2string(x: MyString) = x.s object Apply { def unapply(s: MyString): Option[String] = Some(s) } But I'm not able to use it as I would expect: val Apply(z) = "a" // error: scrutinee is incompatible with pattern type Can anyone explain why it fails to convert the parameter from String to MyString ? I would expect it to call string2mystring("a") on the fly.

I don't really get this little thingy. I have an abstract class Box with several sub-classes for different types. For example abstract class Box class StringBox(val sValue : String) extends Box The apply method in the companion object for Box is simple: object Box{ def apply(s: String) = new StringBox(s) def apply(b: Boolean) = new BooleanBox(b) def apply(d: Double) = new DoubleBox(d) } so I can write val sb = Box("StringBox) Okay, writing unapply makes some trouble. My first idea was to use pattern matching on the type, like this this: def unapply(b: Box) = b match { case sb: StringBox =>

I have created a class called CaseInsensitive which wraps a string (see Implementing a string class that does case insensitive comparisions in Scala ). I've created a case class which has a member variable of type CaseInsensitive, so it gets a default unapply method, which extracts a variable of type CaseInsensitive, but I was hoping to use it like this: case class PropertyKey( val name : CaseInsensitive ) val foo = new PropertyKey("foo") val result = foo match { case PropertyKey("foo") => true case _ => false } This code fails to compile: (on the extractor line, not the constructor line) type