Subtyping function parameters in Scala

Question

I am trying to define an abstract class that has operators to compare two instances of the class. When concretizing the class, however, I want the methods to only compare instances of the same type. Something like this

abstract class ComparableSuper{
  def <(other: ComparableSuper): Boolean  
  def <=(other: ComparableSuper): Boolean  
  def >(other: ComparableSuper): Boolean
  def >=(other: ComparableSuper): Boolean
}


class Comparable (val a: Int) extends ComparableSuper {
   def <(other: Comparable): Boolean = this.a < other.a
   def >(other: Comparable): Boolean = this.a > other.a
   def <=(other: Comparable): Boolean = this.a <= other.a
   def >=(other: Comparable): Boolean = this.a >= other.a
}

Of course this code does not compile because I am not overriding the methods in the abstract class. If I change Comparable to ComparableSuper in the methods, however, I won't have the assurance that the field a is there.

Is there a way I could specify the type of the class in the method signature?

Thanks in advance.

tenshi · Accepted Answer · 2012-06-14 20:24:04Z

3

I highly recommend you to look at Ordering type class.

I find, that type-class approach to this problem is much better than Comaprable way of doing it (where objects, that you want to compare, actually extend Comparable).

With type-class approach you will also give you more type-safety and flexibility. You can actually define Ordering instances for existing classes (classes that you can't control and change).

Ordering can be a little bit clumsy to use, but Ordered has implicits that will allow you to write code like this:

import math.Ordered._

def isGreater[T : Ordering](a: T, b: T) = a > b

So you even don't compromise convenience. (by the way, Ordered is equivalent to Java's Comparable)

edited Jun 14, 2012 at 20:24

answered Jun 14, 2012 at 20:10

tenshi

26.6k8 gold badges80 silver badges91 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

lasaro Over a year ago

Thanks a lot. Ordered seems to be exactly what I needed. And as a bonus I also discovered PartiallyOrdered, which I'll need somewhere else in my code.

Travis Brown · Accepted Answer · 2012-06-14 22:03:55Z

2

In this case using math.Ordered or math.Ordering is a better idea, but if you do need this pattern, you can use F-bounded polymorphism:

trait Foo[A <: Foo[A]] {
  def f(that: A): Int
}

class Bar(val x: Int) extends Foo[Bar] {
  def f(that: Bar) = this.x - that.x
}

There's a bit of syntactic overhead involved in parametrizing the supertype, but it allows you to have methods that require an instance of the same subclass.

answered Jun 14, 2012 at 22:03

Travis Brown

139k12 gold badges384 silver badges689 bronze badges

1 Comment

lasaro Over a year ago

Great. Although Ordered seems to solve the problem at hand, I see where F-bounded polymorphism could be really useful.

Collectives™ on Stack Overflow

Subtyping function parameters in Scala

2 Answers 2

1 Comment

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related