A comparision of Non-Ordered.

OrderedCompareTest2.scala

package net.wrap_trap.scala.examples

import java.util.Comparator

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

        System.out.println("called main")
        // compile error when disabling nonOrderedClassToComparable Method. 
        // No implicit Ordering defined for 
        // net.wrap_trap.scala.examples.OrderedCompareTest2.NonOrderedClass.
        System.out.println(
            compareAB(new NonOrderedClass(4), new NonOrderedClass(3)))     
    }
    
    class NonOrderedClass(val n: Int) {}

    implicit def nonOrderedClassToComparable(from: NonOrderedClass): Comparable[NonOrderedClass] = {
        new Comparable[NonOrderedClass] {
            def compareTo(b: NonOrderedClass): Int = {
                from.n - b.n
            }
        }
    }
    
    // View Bound from scala.math.LowPriorityOrderingImplicits 
    implicit def ordered[T <% Comparable[T]]: Ordering[T] = new Ordering[T] {
    /* = implicit def ordered[T](implicit f: T => Comparable[T]): Ordering[T] = new Ordering[T] { */
        def compare(x: T, y: T): Int = {
            x.compareTo(y) 
        }
    }
    
    // Context Bound
    def compareAB[K:Ordering](a: K, b: K): Int = {
    /* = def compareAB2[K](a: K, b: K)(implicit comp: Ordering[K]): Int = { */
        val comp = Ordering[K]
        System.out.println("called compareAB comp:" + comp)
        comp.compare(a, b);
    }
}