Be Consistent About Providing An Ordering Instance

We sometimes have data types which subtype Ordered and other times have types which implement Ordering. We only need to do Ordering. We should ensure that all types which are Ordered also have an Ordering instance.

Context: https://github.com/http4s/http4s/pull/5013#discussion_r682655331

[isomarcte]

@san-coding if a class is already extending Ordered, we need to leave it that way, at least for now. This is so we don’t break binary compatibility.

In the context of this ticket, any type in http4s which is currently only extending Ordered should also have an implicit Ordering added, and they should be consistent with each other.

Hopefully, most of the types which are extending Ordered have a cats.kernel.Order instance. If they do, then adding the Ordering is very simple. For example,

final case class Foo(bar: Int) extends Ordered[Foo] {
    override final def compare(that: Foo): Int = 
      // Ordered derived from cats Order instance
      Order[Foo].compare(this, that)
}

object Foo {
    implicit val catsOrderInstanceForFoo: Order[Foo] = new Order[Foo] {
      override def compare(x: Foo, y: Foo): Int = x.bar.compare(y.bar)
    }
    
    // scala Ordering derived from cats Order
    implicit val stdLibOrderingInstance: Ordering[Foo] = catsOrderInstanceForFoo.toOrdering
}

If they don’t have a cats.kernel.Order instance (which you are free to add as well if you’d like, or not, either way), as in the case of HttpDate, then we’d do something like this.

class HttpDate private (val epochSecond: Long) extends Renderable with Ordered[HttpDate] { /* elided */ }

object HttpDate {
    implicit val stdLibOrderingInstance: Ordering[HttpDate] = /* Ordering definition */
}

For the sake of consistency, I’d also probably make the compare method from Ordered and the equals method (if it’s not a case class) use the underlying Ordering instance. Something like,

class HttpDate private (val epochSecond: Long) extends Renderable with Ordered[HttpDate] { 
  override def compare(that: HttpDate): Int = 
    Ordering[HttpDate].compare(this, that)
    
  override def equals(o: Any): Boolean = 
    o match {
      case that: HttpDate => Ordering[HttpDate].compare(this, that) === 0
      case _ => false
    }

That was a lot of text…let me know if that makes sense and don’t hesitate to reach out if you have questions.

[san-coding]

@isomarcte @rossabaker have opened a PR for adding Ordering instance QValue class