Scala: pattern matching on nested type hierarchies

Question

Let's say I have

sealed trait AlphaNumericChar

sealed trait AlphaChar
case object A extends AlphaNumericChar with AlphaChar
case object B extends AlphaNumericChar with AlphaChar

sealed trait NumericChar
case object One extends AlphaNumericChar with NumericChar
case object Two extends AlphaNumericChar with NumericChar

This structure allows me to pattern match on AlphaNumericChar and get all A,B,One,Two and similarly pattern match on AlphaChar and NumericChar and get only the relevant objects.

What it doesn't allow me, is to write:

def foo(x: AlphaNumericChar) = ???
def bar(x: AlphaChar) = foo(x)

ie, proxy calls to foo for only certain types. I can of course write instead:

def baz(x: AlphaNumericChar with AlphaChar) = foo(x) 

and that would work but that's perhaps a bit ugly.

Alternative is to make AlphaChar and NumericChar extend AlphaNumericChar but that would mess with my pattern matches on AlphaNumericChar as I will now have to handle _:AlphaChar and _:NumericChar in addition to my case objects which is undesirable.

Is there a way of somehow having the best of two worlds? ie.

• The exhaustive list of pattern match entries on AlphaChar/NumericChar has only two elements.
• The exhaustive list of pattern match entries on AlphaNumericChar has only two elements.
• I can have the bar function above working without resorting to the baz syntax.

Answer 1

Extending AlphaNumericChar shouldn't be a problem. Something like this works fine:

sealed trait AlphaNumericChar

sealed trait AlphaChar extends AlphaNumericChar

case object A extends AlphaChar
case object B extends AlphaChar

sealed trait NumericChar extends AlphaNumericChar

case object One extends NumericChar
case object Two extends NumericChar

def foo(x: AlphaNumericChar) = x match {
  case One => println("hi")
  case Two => println("bye")
  case A => println("foo")
  case B => println("bar")
}

def bar(x: AlphaChar) = foo(x)

def aThirdFunction(y: NumericChar) = y match {
  case One => println("eggs")
  case Two => println("beans")
}

foo(One)  // hi
foo(Two)  // bye
foo(A)    // foo
foo(B)    // bar
bar(A)    // foo
bar(B)    // bar
aThirdFunction(One) // eggs
aThirdFunction(Two) // beans

Unless I've misunderstood what you want?