ListOrder

Instance Constructors

new ListOrder()(implicit ev: Order[A])

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def and(that: Eq[List[A]]): Eq[List[A]]

Return an Eq that gives the result of the and of this and that note this is idempotent
Return an Eq that gives the result of the and of this and that note this is idempotent

Definition Classes
Eq
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def compare(xs: List[A], ys: List[A]): Int

Result of comparing x with y.
Result of comparing x with y. Returns an Int whose sign is: - negative iff x < y - zero iff x = y - positive iff x > y

Definition Classes
ListOrder → Order
def comparison(x: List[A], y: List[A]): Comparison

Like compare, but returns a cats.kernel.Comparison instead of an Int.
Like compare, but returns a cats.kernel.Comparison instead of an Int. Has the benefit of being able to pattern match on, but not as performant.

Definition Classes
Order
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def eqv(x: List[A], y: List[A]): Boolean

Returns true if x = y, false otherwise.
Returns true if x = y, false otherwise.

Definition Classes
Order → PartialOrder → Eq
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def gt(x: List[A], y: List[A]): Boolean

Returns true if x > y, false otherwise.
Returns true if x > y, false otherwise.

Definition Classes
Order → PartialOrder
def gteqv(x: List[A], y: List[A]): Boolean

Returns true if x >= y, false otherwise.
Returns true if x >= y, false otherwise.

Definition Classes
Order → PartialOrder
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lt(x: List[A], y: List[A]): Boolean

Returns true if x < y, false otherwise.
Returns true if x < y, false otherwise.

Definition Classes
Order → PartialOrder
def lteqv(x: List[A], y: List[A]): Boolean

Returns true if x <= y, false otherwise.
Returns true if x <= y, false otherwise.

Definition Classes
Order → PartialOrder
def max(x: List[A], y: List[A]): List[A]

If x >= y, return x, else return y.
If x >= y, return x, else return y.

Definition Classes
Order
def min(x: List[A], y: List[A]): List[A]

If x <= y, return x, else return y.
If x <= y, return x, else return y.

Definition Classes
Order
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def neqv(x: List[A], y: List[A]): Boolean

Returns true if x != y, false otherwise.
Returns true if x != y, false otherwise.

Definition Classes
Order → Eq
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def on[B](f: (B) ⇒ List[A]): Order[B]

Defines an order on B by mapping B to A using f and using As order to order B.
Defines an order on B by mapping B to A using f and using As order to order B.

Definition Classes
Order → PartialOrder → Eq
def or(that: Eq[List[A]]): Eq[List[A]]

Return an Eq that gives the result of the or of this and that Note this is idempotent
Return an Eq that gives the result of the or of this and that Note this is idempotent

Definition Classes
Eq
def partialCompare(x: List[A], y: List[A]): Double

Result of comparing x with y.
Result of comparing x with y. Returns NaN if operands are not comparable. If operands are comparable, returns a Double whose sign is: - negative iff x < y - zero iff x = y - positive iff x > y

Definition Classes
Order → PartialOrder
def partialComparison(x: List[A], y: List[A]): Option[Comparison]

Like partialCompare, but returns a cats.kernel.Comparison instead of an Double.
Like partialCompare, but returns a cats.kernel.Comparison instead of an Double. Has the benefit of being able to pattern match on, but not as performant.

Definition Classes
PartialOrder
def pmax(x: List[A], y: List[A]): Option[List[A]]

Returns Some(x) if x >= y, Some(y) if x < y, otherwise None.
Returns Some(x) if x >= y, Some(y) if x < y, otherwise None.

Definition Classes
PartialOrder
def pmin(x: List[A], y: List[A]): Option[List[A]]

Returns Some(x) if x <= y, Some(y) if x > y, otherwise None.
Returns Some(x) if x <= y, Some(y) if x > y, otherwise None.

Definition Classes
PartialOrder
def reverse: Order[List[A]]

Defines an ordering on A where all arrows switch direction.
Defines an ordering on A where all arrows switch direction.

Definition Classes
Order → PartialOrder
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toOrdering: Ordering[List[A]]

Convert a Order[A] to a scala.math.Ordering[A] instance.
Convert a Order[A] to a scala.math.Ordering[A] instance.

Definition Classes
Order
def toString(): String

Definition Classes
AnyRef → Any
def tryCompare(x: List[A], y: List[A]): Option[Int]

Result of comparing x with y.
Result of comparing x with y. Returns None if operands are not comparable. If operands are comparable, returns Some[Int] where the Int sign is: - negative iff x < y - zero iff x = y - positive iff x > y

Definition Classes
PartialOrder
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def whenEqual(o: Order[List[A]]): Order[List[A]]

Returns a new Order[A] instance that first compares by the original Order instance and uses the provided Order instance to "break ties".
Returns a new Order[A] instance that first compares by the original Order instance and uses the provided Order instance to "break ties".
That is, x.whenEqual(y) creates an Order that first orders by x and then (if two elements are equal) falls back to y for the comparison.

Definition Classes
Order

class ListOrder[A] extends Order[List[A]]

Instance Constructors

new ListOrder()(implicit ev: Order[A])

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def and(that: Eq[List[A]]): Eq[List[A]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compare(xs: List[A], ys: List[A]): Int

def comparison(x: List[A], y: List[A]): Comparison

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eqv(x: List[A], y: List[A]): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def gt(x: List[A], y: List[A]): Boolean

def gteqv(x: List[A], y: List[A]): Boolean

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def lt(x: List[A], y: List[A]): Boolean

def lteqv(x: List[A], y: List[A]): Boolean

def max(x: List[A], y: List[A]): List[A]

def min(x: List[A], y: List[A]): List[A]

final def ne(arg0: AnyRef): Boolean

def neqv(x: List[A], y: List[A]): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def on[B](f: (B) ⇒ List[A]): Order[B]

def or(that: Eq[List[A]]): Eq[List[A]]

def partialCompare(x: List[A], y: List[A]): Double

def partialComparison(x: List[A], y: List[A]): Option[Comparison]

def pmax(x: List[A], y: List[A]): Option[List[A]]

def pmin(x: List[A], y: List[A]): Option[List[A]]

def reverse: Order[List[A]]

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

def toOrdering: Ordering[List[A]]

def toString(): String

def tryCompare(x: List[A], y: List[A]): Option[Int]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def whenEqual(o: Order[List[A]]): Order[List[A]]

Inherited from Order[List[A]]

Inherited from PartialOrder[List[A]]

Inherited from Eq[List[A]]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped