AlphaNumName

abstract def companionName: Name

abstract def isTermName: Boolean

abstract def isTypeName: Boolean

abstract def nameKind: String

abstract def newName(str: String): ThisNameType

Return a new name of the same variety.

abstract def next: ThisNameType

The next name in the same hash bucket.

abstract def subName(from: Int, to: Int): ThisNameType

Return the subname with characters from from to to-1.

abstract def thisName: ThisNameType

abstract def toTermName: TermName

abstract def toTypeName: TypeName

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (AlphaNumName, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def andThen[A](g: (Char) ⇒ A): (Int) ⇒ A

def append(suffix: Name): ThisNameType

def append(suffix: String): ThisNameType

def append(ch: Char): ThisNameType

TODO - find some efficiency.

final def apply(i: Int): Char

final def asInstanceOf[T0]: T0

def bothNames: List[Name]

def clone(): AnyRef

def compose[A](g: (A) ⇒ Int): (A) ⇒ Char

final def containsChar(ch: Char): Boolean

final def containsName(subname: Name): Boolean

final def containsName(subname: String): Boolean

final def copyChars(cs: Array[Char], offset: Int): Unit

Copy bytes of this name to buffer cs, starting at position offset.

final def copyUTF8(bs: Array[Byte], offset: Int): Int

Write to UTF8 representation of this name to given character array.

def debugString: String

final def decode: String

Replace $op_name by corresponding operator symbol.

def decoded: String

!!! Duplicative but consistently named.

final def decodedName: ThisNameType

def drop(n: Int): ThisNameType

def dropRight(n: Int): ThisNameType

final def encode: ThisNameType

Replace operator symbols by corresponding $op_name.

def encoded: String

def encodedName: ThisNameType

final def endChar: Char

final def endsWith(name: String): Boolean

final def endsWith(char: Char): Boolean

final def endsWith(suffix: Name, end: Int): Boolean

Does this name end with suffix just before given end index?

final def endsWith(suffix: Name): Boolean

Does this name end with suffix?

def ensuring(cond: (AlphaNumName) ⇒ Boolean, msg: ⇒ Any): AlphaNumName

def ensuring(cond: (AlphaNumName) ⇒ Boolean): AlphaNumName

def ensuring(cond: Boolean, msg: ⇒ Any): AlphaNumName

def ensuring(cond: Boolean): AlphaNumName

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

final def hashCode(): Int

val index: Int

def indexOf(ch: Char, fromIndex: Int): Int

def indexOf(ch: Char): Int

final def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

final def isOperatorName: Boolean

def lastIndexOf(ch: Char, fromIndex: Int): Int

def lastIndexOf(ch: Char): Int

final def lastPos(s: String, start: Int): Int

Returns the index of the last occurrence of string s in this name from start, -1 if not found.

final def lastPos(c: Char, start: Int): Int

Returns the index of the last occurrence of char c in this name from start, -1 if not found.

final def lastPos(s: String): Int

final def lastPos(c: Char): Int

Returns the index of last occurrence of char c in this name, -1 if not found.

val len: Int

final def length: Int

The length of this name.

def longString: String

def mapName(f: (String) ⇒ String): ThisNameType

Return a new name based on string transformation.

final def ne(arg0: AnyRef): Boolean

final def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def pos(s: String, start: Int): Int

Returns the index of the first occurrence of nonempty string s in this name from start, length if not found.

final def pos(c: Char, start: Int): Int

Returns the index of the first occurrence of character c in this name from start, length if not found.

final def pos(s: String): Int

final def pos(c: Char): Int

def prepend(prefix: Name): ThisNameType

def prepend(prefix: String): ThisNameType

def prepend(ch: Char): ThisNameType

def replace(from: Char, to: Char): Name

Replace all occurrences of from by to in name; result is always a term name.

val self: Any

val self: Any

def start: Int

Index into name table

final def startChar: Char

Some thoroughly self-explanatory convenience functions.

final def startsWith(name: String): Boolean

final def startsWith(char: Char): Boolean

final def startsWith(prefix: Name, start: Int): Boolean

Does this name start with prefix at given start index?

final def startsWith(prefix: Name): Boolean

Does this name start with prefix?

def stripSuffix(suffix: Name): ThisNameType

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

final def toChars: Array[Char]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (AlphaNumName, B)

def x: AlphaNumName

def x: AlphaNumName