object Test2 {
  import Test._, Implicits1._, Implicits2._

  abstract class TimeStamp(val toLong: Long) extends Ordered[TimeStamp]

  implicitly[Ordering[TimeStamp]]
  implicitly[Ordering[(Int,TimeStamp)]]
}

object Test {
  class Ordering[T]
  abstract class Ordered[T] extends java.lang.Comparable[T]
  trait Low {
     implicit def ordered[A <% java.lang.Comparable[A]]: Ordering[A] = ???
     implicit def comparatorToOrdering[A](implicit cmp: java.util.Comparator[A]): Ordering[A] = ???
  }
  object Implicits1 extends Low {
    implicit def OrderingInt: Ordering[Int] = ???
    implicit def OrderingTuple2[A: Ordering, B: Ordering]: Ordering[(A, B)] = ???

  }
  object Implicits2 {
    implicit def orderingToOrdered[T](x: T)(implicit ord: Ordering[T]): Ordered[T] = ???
  }
}

implicit def ordered[A <% java.lang.Comparable[A]]: Ordering[A] = ???

implicit def ordered[A <: java.lang.Comparable[A]]: Ordering[A] = ???

object Test2 {
   class TimeStamp(val toLong: Long) extends AnyVal
   object TimeStamp {
     implicit def TimeStampOrdering: Ordering[TimeStamp] = Ordering.by(_.toLong)
   }
 
   // while looking irrelevant, these two code lines are needed to reproduce the bug
   case class L(time: TimeStamp)
   List.empty[L].sortBy(_.time)
 
   // this line triggers compiler error "diverging implicit expansion for type scala.math.Ordering[(Int, Test2.TimeStamp)] starting with method $conforms in object Predef"
   List.empty[(Int,TimeStamp)].sorted  
}

import org.apache.spark.rdd.RDD


class Bar(v: Int) extends Ordered[Bar] {
  def compare(that: Bar): Int = ???
}

object App {

  def main(args: Array[String]): Unit = {

    val dataSet: RDD[Baz] = ???

    // This works - Case 1
    val pairs = RDD.rddToPairRDDFunctions(dataSet)

    pairs.reduceByKey(merge _)

    // This does not work!! - Case 2
    RDD.rddToPairRDDFunctions(dataSet).reduceByKey(merge _)

    // This does not work!! - Case 3
    dataSet.reduceByKey(merge _)
  }

  type Baz = ((Bar, Option[Bar]), Int)

  def merge(b1: Int, b2: Int): Int = ???
}

Welcome to Scala 2.12.3 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_144).
Type in expressions for evaluation. Or try :help.

scala> :paste
// Entering paste mode (ctrl-D to finish)

import java.time.OffsetDateTime
import scala.concurrent.duration.FiniteDuration

implicitly[Ordering[OffsetDateTime]]
implicitly[Ordering[FiniteDuration]]

// Exiting paste mode, now interpreting.

<console>:17: error: diverging implicit expansion for type Ordering[scala.concurrent.duration.FiniteDuration]
starting with method $conforms in object Predef
       implicitly[Ordering[FiniteDuration]]
                 ^

scala> :paste
// Entering paste mode (ctrl-D to finish)

import java.time.OffsetDateTime
import scala.concurrent.duration.FiniteDuration

implicitly[Ordering[FiniteDuration]]
implicitly[Ordering[OffsetDateTime]]

// Exiting paste mode, now interpreting.

import java.time.OffsetDateTime
import scala.concurrent.duration.FiniteDuration
res0: Ordering[java.time.OffsetDateTime] = scala.math.LowPriorityOrderingImplicits$$anon$6@60c73e58