object Predef extends LowPriorityImplicits

The Predef object provides definitions that are accessible in all Scala compilation units without explicit qualification.


  1. LowPriorityImplicits
  2. AnyRef
  3. Any

Type Members

  1. class <%<[-From, +To] extends (From) ⇒ To

  2. class <:<[-From, +To] extends (From) ⇒ To

  3. class =:=[From, To] extends (From) ⇒ To

  4. class ArrowAssoc[A] extends AnyRef

  5. type Class = Class[T]

  6. type ClassManifest = ClassManifest[T]

  7. class DummyImplicit extends AnyRef

    A type for which there is aways an implicit value

  8. class Ensuring[A] extends AnyRef

  9. type Function = (A) ⇒ B

  10. type Manifest = Manifest[T]

  11. type Map = Map[A, B]

  12. type Pair = (A, B)

  13. type Set = Set[A]

  14. type String = String

  15. type Triple = (A, B, C)

Value Members

  1. object <%< extends AnyRef

  2. object =:= extends AnyRef

  3. object DummyImplicit extends AnyRef

  4. val Map: Map

  5. object Pair extends AnyRef

  6. val Set: Set

  7. object Triple extends AnyRef

  8. def any2ArrowAssoc[A](x: A): ArrowAssoc[A]

  9. def any2Ensuring[A](x: A): Ensuring[A]

  10. def any2stringadd(x: Any): StringAdd

  11. def arrayToCharSequence(xs: Array[Char]): CharSequence

  12. def assert(assertion: Boolean, message: ⇒ Any): Unit

  13. def assert(assertion: Boolean): Unit

  14. def assume(assumption: Boolean, message: ⇒ Any): Unit

  15. def assume(assumption: Boolean): Unit

  16. def augmentString(x: String): StringOps

  17. def boolean2Boolean(x: Boolean): Boolean

  18. def booleanArrayOps(xs: Array[Boolean]): ArrayOps[Boolean]

  19. def booleanWrapper(x: Boolean): RichBoolean

  20. def byte2Byte(x: Byte): Byte

  21. def byte2double(x: Byte): Double

  22. def byte2float(x: Byte): Float

  23. def byte2int(x: Byte): Int

  24. def byte2long(x: Byte): Long

  25. def byte2short(x: Byte): Short

  26. def byteArrayOps(xs: Array[Byte]): ArrayOps[Byte]

  27. def byteWrapper(x: Byte): RichByte

  28. def char2Character(x: Char): Character

  29. def char2double(x: Char): Double

  30. def char2float(x: Char): Float

  31. def char2int(x: Char): Int

  32. def char2long(x: Char): Long

  33. def charArrayOps(xs: Array[Char]): ArrayOps[Char]

  34. def charWrapper(c: Char): RichChar

  35. def classManifest[T](m: ClassManifest[T]): ClassManifest[T]

  36. def classOf[T]: Class[T]

    Return the runtime representation of a class type

    Return the runtime representation of a class type. This is a stub method. The actual implementation is filled in by the compiler.

  37. def conforms[A]: <:<[A, A]

  38. def currentThread: Thread

  39. def double2Double(x: Double): Double

  40. def doubleArrayOps(xs: Array[Double]): ArrayOps[Double]

  41. def doubleWrapper(x: Double): RichDouble

  42. def equals(arg0: Any): Boolean

    This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence

    This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence.

    The default implementations of this method is an equivalence relation:

    • It is reflexive: for any instance x of type Any, x.equals(x) should return true.
    • It is symmetric: for any instances x and y of type Any, x.equals(y) should return true if and only if y.equals(x) returns true.
    • It is transitive: for any instances x, y, and z of type AnyRef if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.

    If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is often necessary to override hashCode to ensure that objects that are "equal" (o1.equals(o2) returns true) hash to the same Int (o1.hashCode.equals(o2.hashCode)).


    the object to compare against this object for equality.


    true if the receiver object is equivalent to the argument; false otherwise.

    definition classes: AnyRef ⇐ Any
  43. def error(message: String): Nothing

  44. def exceptionWrapper(exc: Throwable): RichException

  45. def exit(status: Int): Nothing

  46. def exit(): Nothing

  47. def fallbackStringCanBuildFrom[T]: CanBuildFrom[String, T, IndexedSeq[T]]

  48. def float2Float(x: Float): Float

  49. def float2double(x: Float): Double

  50. def floatArrayOps(xs: Array[Float]): ArrayOps[Float]

  51. def floatWrapper(x: Float): RichFloat

  52. def format(text: String, xs: Any*): String

  53. def genericArrayOps[T](xs: Array[T]): ArrayOps[T]

  54. def genericWrapArray[T](xs: Array[T]): WrappedArray[T]

  55. def hash(x: Int): Int

  56. def hash(x: Long): Int

  57. def hash(x: Number): Int

  58. def hash(x: Any): Int

  59. def hashCode(): Int

    Returns a hash code value for the object

    Returns a hash code value for the object.

    The default hashing algorithm is platform dependent.

    Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)) yet not be equal (o1.equals(o2) returns false). A degenerate implementation could always return 0. However, it is required that if two objects are equal (o1.equals(o2) returns true) that they have identical hash codes (o1.hashCode.equals(o2.hashCode)). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the equals method.

    definition classes: AnyRef ⇐ Any
  60. def identity[A](x: A): A

  61. def implicitly[T](e: T): T

  62. def int2Integer(x: Int): Integer

  63. def int2double(x: Int): Double

  64. def int2float(x: Int): Float

  65. def int2long(x: Int): Long

  66. def intArrayOps(xs: Array[Int]): ArrayOps[Int]

  67. def intWrapper(x: Int): RichInt

  68. def locally[T](x: T): T

  69. def long2Long(x: Long): Long

  70. def long2double(x: Long): Double

  71. def long2float(x: Long): Float

  72. def longArrayOps(xs: Array[Long]): ArrayOps[Long]

  73. def longWrapper(x: Long): RichLong

  74. def manifest[T](m: Manifest[T]): Manifest[T]

  75. def print(x: Any): Unit

  76. def printf(text: String, xs: Any*): Unit

  77. def println(x: Any): Unit

  78. def println(): Unit

  79. def readBoolean(): Boolean

  80. def readByte(): Byte

  81. def readChar(): Char

  82. def readDouble(): Double

  83. def readFloat(): Float

  84. def readInt(): Int

  85. def readLine(text: String, args: Any*): String

  86. def readLine(): String

  87. def readLong(): Long

  88. def readShort(): Short

  89. def readf(format: String): List[Any]

  90. def readf1(format: String): Any

  91. def readf2(format: String): (Any, Any)

  92. def readf3(format: String): (Any, Any, Any)

  93. def refArrayOps[T <: AnyRef](xs: Array[T]): ArrayOps[T]

  94. def require(requirement: Boolean, message: ⇒ Any): Unit

  95. def require(requirement: Boolean): Unit

  96. def seqToCharSequence(xs: IndexedSeq[Char]): CharSequence

  97. def short2Short(x: Short): Short

  98. def short2double(x: Short): Double

  99. def short2float(x: Short): Float

  100. def short2int(x: Short): Int

  101. def short2long(x: Short): Long

  102. def shortArrayOps(xs: Array[Short]): ArrayOps[Short]

  103. def shortWrapper(x: Short): RichShort

  104. def stringCanBuildFrom: CanBuildFrom[String, Char, String]

  105. def toString(): String

    Returns a string representation of the object

    Returns a string representation of the object.

    The default representation is platform dependent.

    definition classes: AnyRef ⇐ Any
  106. def unaugmentString(x: StringOps): String

  107. def unitArrayOps(xs: Array[Unit]): ArrayOps[Unit]

  108. def unwrapString(ws: WrappedString): String

  109. def wrapArray(xs: Array[Unit]): WrappedArray[Unit]

  110. def wrapArray(xs: Array[Boolean]): WrappedArray[Boolean]

  111. def wrapArray(xs: Array[Short]): WrappedArray[Short]

  112. def wrapArray(xs: Array[Byte]): WrappedArray[Byte]

  113. def wrapArray(xs: Array[Char]): WrappedArray[Char]

  114. def wrapArray(xs: Array[Float]): WrappedArray[Float]

  115. def wrapArray(xs: Array[Long]): WrappedArray[Long]

  116. def wrapArray(xs: Array[Double]): WrappedArray[Double]

  117. def wrapArray(xs: Array[Int]): WrappedArray[Int]

  118. def wrapArray[T <: AnyRef](xs: Array[T]): WrappedArray[T]

    Can go away after next newstarr

    Can go away after next newstarr

    definition classes: LowPriorityImplicits
  119. def wrapBooleanArray(xs: Array[Boolean]): WrappedArray[Boolean]

  120. def wrapByteArray(xs: Array[Byte]): WrappedArray[Byte]

  121. def wrapCharArray(xs: Array[Char]): WrappedArray[Char]

  122. def wrapDoubleArray(xs: Array[Double]): WrappedArray[Double]

  123. def wrapFloatArray(xs: Array[Float]): WrappedArray[Float]

  124. def wrapIntArray(xs: Array[Int]): WrappedArray[Int]

  125. def wrapLongArray(xs: Array[Long]): WrappedArray[Long]

  126. def wrapRefArray[T <: AnyRef](xs: Array[T]): WrappedArray[T]

  127. def wrapShortArray(xs: Array[Short]): WrappedArray[Short]

  128. def wrapString(s: String): WrappedString

  129. def wrapUnitArray(xs: Array[Unit]): WrappedArray[Unit]