ContravariantCoyonedaUsage

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Binfmt

def CCBinOrd[A, B](f: (A) ⇒ B)(implicit b: Binfmt[B], o: Order[B]): Aux[BinOrd, A, B]

val CCOrder: By[Order]

object SortType

def args: Array[String]

final def asInstanceOf[T0]: T0

def binOrdFanout[A](l: ContravariantCoyoneda[BinOrd, A], r: ContravariantCoyoneda[BinOrd, A]): Aux[BinOrd, A, (I, I)]

val binfmtdesc: String

val byDirectSorts: List[List[Vector[String]]]

val byOrdListSorts: List[List[Vector[String]]]

val bySchwartzianListSorts: List[List[Vector[String]]]

val bySchwartzianListSortsTP: List[List[Vector[String]]]

def caseInsensitively(s: String): String

def caseInsensitivelyOrd: Order[String]

def clone(): AnyRef

implicit def ctCoyoBinOrdMonoid[A]: Monoid[ContravariantCoyoneda[BinOrd, A]]

implicit def ctCoyoOrdMonoid[A]: Monoid[ContravariantCoyoneda[Order, A]]

def dateOrd: Order[String]

val decomposedSortKeys: List[(ContravariantCoyoneda[Order, String], Int)]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val executionStart: Long

def finalize(): Unit

val finalsort: List[Vector[String]]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

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

val mainLtoRcoyo: ContravariantCoyoneda[Order, Vector[String]]

val mainLtoRcoyoL: ContravariantCoyoneda[Order, Vector[String]]

val mainLtoRsort: SortSpec

val mainLtoRtailcoyo: ContravariantCoyoneda[Order, Vector[String]]

final def ne(arg0: AnyRef): Boolean

def nonschwartzian[A, B](xs: List[A])(f: (A) ⇒ B)(implicit B: Order[B]): List[A]

final def notify(): Unit

final def notifyAll(): Unit

def numerically1: Order[String]

def numerically2: Order[String]

def numerically3: Order[String]

val numerically4: ContravariantCoyoneda[Order, String]

def ordFanout[A](l: ContravariantCoyoneda[Order, A], r: ContravariantCoyoneda[Order, A]): Aux[Order, A, (I, I)]

def parseCommaNum(s: String): \/[Long, String]

def parseDate(s: String): \/[(Int, Option[(Int, Int)]), String]

def recItem[F[_]](i: Int, o: ContravariantCoyoneda[F, String]): ContravariantCoyoneda[F, Vector[String]]

def recItemOrd(i: Int, o: ContravariantCoyoneda[Order, String]): ContravariantCoyoneda[Order, Vector[String]]

def schwartzian[A, B](xs: List[A])(f: (A) ⇒ B)(implicit B: Order[B]): List[A]

def sortDataBy(xs: List[Vector[String]], o: SortSpec): List[Vector[String]]

def sortSpecBinOrdF(s: SortSpec): ContravariantCoyoneda[BinOrd, Vector[String]]

def sortSpecOrd(s: SortSpec): ContravariantCoyoneda[Order, Vector[String]]

def sortSpecOrdF(s: SortSpec): ContravariantCoyoneda[Order, Vector[String]]

def sortSpecOrdL(s: SortSpec): ContravariantCoyoneda[Order, Vector[String]]

def sortTypeBinOrd(s: SortType): ContravariantCoyoneda[BinOrd, String]

def sortTypeOrd(s: SortType): ContravariantCoyoneda[Order, String]

val sortedByNonCity: List[Vector[String]]

val sortedByNonCityL: List[Vector[String]]

val sortedBySpec: List[Vector[String]]

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

def toString(): String

def unitBinOrd[A]: Aux[BinOrd, A, Unit]

def unitOrd[A]: Aux[Order, A, Unit]

Forget the value, treat all as equal.

val unstructuredData: List[Vector[String]]

val untypedSortKeys: List[((String) ⇒ Serializable, Int)]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def delayedInit(body: ⇒ Unit): Unit