Key

abstract def compareAt(a: K, ai: Int, b: K, bi: Int): Int

Compare key a at index ai with key b at index bi.

abstract def concat(a: K, b: K): K

abstract def empty: K

The empty key

abstract def eqv(x: K, y: K): Boolean

abstract def hash(e: K): Int

abstract def indexOfFirstDifference(a: K, ai: Int, b: K, bi: Int, count: Int): Int

Starting from a at ai and b at bi, compares elements of a and b until count elements have been compared or until a difference has been found.

abstract def intern(e: K): K

An identity function for keys that can perform interning as an optimization

abstract def size(c: K): Int

The size of a key

abstract def slice(a: K, from: Int, until: Int): K

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def and(that: Eq[K]): Eq[K]

final def asInstanceOf[T0]: T0

final def binarySearch[V](elems: Array[RadixTree[K, V]], elem: K, offset: Int): Int

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def indexOf(a: K, b: K): Int

final def isInstanceOf[T0]: Boolean

final def mergeChildren[V](a: Array[RadixTree[K, V]], b: Array[RadixTree[K, V]], f: (V, V) ⇒ V): Array[RadixTree[K, V]]

final def ne(arg0: AnyRef): Boolean

def neqv(x: K, y: K): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def on[B](f: (B) ⇒ K): Hash[B]

Constructs a new Eq instance for type B where 2 elements are equivalent iff eqv(f(x), f(y)).

def or(that: Eq[K]): Eq[K]

def regionMatches(a: K, ai: Int, b: K, bi: Int, count: Int): Boolean

def startsWith(a: K, b: K, ai: Int): Boolean

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit