HierarchicalOrdering

abstract def compare(x: N, y: N): Int

abstract def isHead(n: N): Boolean

It returns whether n is an head element.

abstract def stringPrefix: String

Defines the prefix of this object's toString representation.

abstract def toSeq: Seq[N]

Returns the elements which are part of the ordering in the correct order.

abstract def toSeqWithParenthesis: Seq[HOElement[N]]

A sequence of elements and parenthesis representing the hierarchical ordering.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def equiv(x: N, y: N): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def gt(x: N, y: N): Boolean

def gteq(x: N, y: N): Boolean

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def lt(x: N, y: N): Boolean

def lteq(x: N, y: N): Boolean

def max(x: N, y: N): N

def min(x: N, y: N): N

implicit def mkOrderingOps(lhs: N): Ops

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def on[U](f: (U) ⇒ N): Ordering[U]

def reverse: Ordering[N]

def reversed(): Comparator[N]

final def synchronized[T0](arg0: ⇒ T0): T0

def thenComparing[U <: Comparable[_ >: U]](arg0: Function[_ >: N, _ <: U]): Comparator[N]

def thenComparing[U](arg0: Function[_ >: N, _ <: U], arg1: Comparator[_ >: U]): Comparator[N]

def thenComparing(arg0: Comparator[_ >: N]): Comparator[N]

def thenComparingDouble(arg0: ToDoubleFunction[_ >: N]): Comparator[N]

def thenComparingInt(arg0: ToIntFunction[_ >: N]): Comparator[N]

def thenComparingLong(arg0: ToLongFunction[_ >: N]): Comparator[N]

def toString(): String

Converts a hierarchical ordering into a string on the basis of its parenthesized sequence

def tryCompare(x: N, y: N): Some[Int]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit