Scala 3

Scala 3/scala/AnyRef

AnyRef

class AnyRef

Class AnyRef is the root class of all reference types. All types except the value types descend from this class.

trait () => R

class FromJavaBooleanSupplier

class FromJavaDoubleSupplier

class FromJavaIntSupplier

class FromJavaLongSupplier

class FromJavaSupplier[T]

trait Reference[T]

trait ReferenceWrapper[T]

class PhantomReference[T]

class SoftReference[T]

class WeakReference[T]

class AbstractFunction0[R]

trait JFunction0$mcB$sp

trait JFunction0$mcC$sp

trait JFunction0$mcD$sp

trait JFunction0$mcF$sp

trait JFunction0$mcI$sp

trait JFunction0$mcJ$sp

trait JFunction0$mcS$sp

trait JFunction0$mcV$sp

trait JFunction0$mcZ$sp

trait T1 => R

class From <:< To

class From =:= To

class Conversion[T, U]

trait PartialFunction[A, B]

trait MapOps[K, V, CC, C]

trait Map[K, V]

class AbstractMap[K, V]

class AbstractMap[K, V]

class HashMap[K, V]

class IntMap[T]

class ListMap[K, V]

class LongMap[T]

class Map1[K, V]

class Map2[K, V]

class Map3[K, V]

class Map4[K, V]

class WithDefault[K, V]

class WithDefault[K, V]

class TreeMap[K, V]

class TreeSeqMap[K, V]

class VectorMap[K, V]

class AbstractMap[K, V]

class TrieMap[K, V]

class AnyRefMap[K, V]

class CollisionProofHashMap[K, V]

class HashMap[K, V]

class LinkedHashMap[K, V]

class ListMap[K, V]

class LongMap[V]

class WithDefault[K, V]

class WithDefault[K, V]

class OpenHashMap[Key, Value]

class TreeMap[K, V]

class SystemProperties

trait DefaultMap[K, V]

trait SeqMap[K, V]

trait SeqMap[K, V]

trait SeqMap[K, V]

trait SortedMap[K, V]

trait SortedMap[K, V]

trait SortedMap[K, V]

trait Map[K, V]

trait Map[K, V]

trait Map[K, V]

trait MultiMap[K, V]

trait MapFactoryDefaults[K, V, CC, WithFilterCC]

class WeakHashMap[K, V]

trait MapView[K, V]

class AbstractMapView[K, V]

class Filter[K, V]

class FilterKeys[K, V]

class Id[K, V]

class MapValues[K, V, W]

class TapEach[K, V, U]

trait SortedMapFactoryDefaults[K, V, CC, WithFilterCC, UnsortedCC]

trait SortedMapOps[K, V, CC, C]

trait StrictOptimizedSortedMapOps[K, V, CC, C]

trait StrictOptimizedSortedMapOps[K, V, CC, C]

trait SortedMapOps[K, V, CC, C]

trait SortedMapOps[K, V, CC, C]

trait StrictOptimizedMapOps[K, V, CC, C]

trait StrictOptimizedMapOps[K, V, CC, C]

trait MapOps[K, V, CC, C]

trait MapOps[K, V, CC, C]

trait Seq[A]

class AbstractSeq[A]

class AbstractSeq[A]

class ArraySeq[A]

class ofBoolean

class ofByte

class ofChar

class ofInt

class ofLong

class ofRef[T]

class ofUnit

class LazyList[A]

class List[A]

class ::[A]

object Nil

class NumericRange[T]

class Exclusive[T]

class Inclusive[T]

class Queue[A]

class Range

class Exclusive

class Inclusive

class Stream[A]

class Cons[A]

object Empty

class Vector[A]

class WrappedString

class AbstractSeq[A]

class AbstractBuffer[A]

class ArrayBuffer[A]

class ArrayDeque[A]

class Queue[A]

class Stack[A]

class ListBuffer[A]

class UnrolledBuffer[T]

class ArraySeq[T]

class ofBoolean

class ofByte

class ofChar

class ofInt

class ofLong

class ofRef[T]

class ofUnit

class StringBuilder

trait IndexedSeq[A]

trait IndexedSeq[A]

trait IndexedSeq[T]

trait IndexedBuffer[A]

trait LinearSeq[A]

trait LinearSeq[A]

trait Seq[A]

trait Seq[A]

trait Buffer[A]

class Accumulator[A, CC, C]

class AnyAccumulator[A]

class DoubleAccumulator

class IntAccumulator

class LongAccumulator

class AbstractPartialFunction[T1, R]

trait SetOps[A, CC, C]

trait Set[A]

class AbstractSet[A]

class AbstractSet[A]

class BitSet

class HashSet[A]

class ListSet[A]

class ImmutableKeySet

class Set1[A]

class Set2[A]

class Set3[A]

class Set4[A]

class ImmutableKeySortedSet

class TreeSet[A]

class AbstractSet[A]

class BitSet

class HashSet[A]

class LinkedHashSet[A]

class TreeSet[A]

trait SortedSet[A]

trait BitSet

trait SortedSet[A]

trait SortedSet[A]

trait Set[A]

trait Set[A]

trait SortedSetOps[A, CC, C]

trait BitSetOps[C]

trait SortedSetFactoryDefaults[A, CC, WithFilterCC]

trait StrictOptimizedSortedSetOps[A, CC, C]

trait StrictOptimizedSortedSetOps[A, CC, C]

trait SortedSetOps[A, CC, C]

trait SortedSetOps[A, CC, C]

trait StrictOptimizedSetOps[A, CC, C]

trait StrictOptimizedSetOps[A, CC, C]

trait SetOps[A, CC, C]

trait SetOps[A, CC, C]

class FromJavaConsumer[T]

class FromJavaDoubleConsumer

class FromJavaDoubleFunction[R]

class FromJavaDoublePredicate

class FromJavaDoubleToIntFunction

class FromJavaDoubleToLongFunction

class FromJavaDoubleUnaryOperator

class FromJavaFunction[T, R]

class FromJavaIntConsumer

class FromJavaIntFunction[R]

class FromJavaIntPredicate

class FromJavaIntToDoubleFunction

class FromJavaIntToLongFunction

class FromJavaIntUnaryOperator

class FromJavaLongConsumer

class FromJavaLongFunction[R]

class FromJavaLongPredicate

class FromJavaLongToDoubleFunction

class FromJavaLongToIntFunction

class FromJavaLongUnaryOperator

class FromJavaPredicate[T]

class FromJavaToDoubleFunction[T]

class FromJavaToIntFunction[T]

class FromJavaToLongFunction[T]

class FromJavaUnaryOperator[T]

class AbstractFunction1[T1, R]

trait JFunction1$mcDD$sp

trait JFunction1$mcDF$sp

trait JFunction1$mcDI$sp

trait JFunction1$mcDJ$sp

trait JFunction1$mcFD$sp

trait JFunction1$mcFF$sp

trait JFunction1$mcFI$sp

trait JFunction1$mcFJ$sp

trait JFunction1$mcID$sp

trait JFunction1$mcIF$sp

trait JFunction1$mcII$sp

trait JFunction1$mcIJ$sp

trait JFunction1$mcJD$sp

trait JFunction1$mcJF$sp

trait JFunction1$mcJI$sp

trait JFunction1$mcJJ$sp

trait JFunction1$mcVD$sp

trait JFunction1$mcVF$sp

trait JFunction1$mcVI$sp

trait JFunction1$mcVJ$sp

trait JFunction1$mcZD$sp

trait JFunction1$mcZF$sp

trait JFunction1$mcZI$sp

trait JFunction1$mcZJ$sp

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) => R

class AbstractFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) => R

class AbstractFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) => R

class AbstractFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) => R

class AbstractFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) => R

class AbstractFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) => R

class AbstractFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) => R

class AbstractFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) => R

class AbstractFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) => R

class AbstractFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) => R

class AbstractFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]

trait (T1, T2) => R

class FromJavaBiConsumer[T, U]

class FromJavaBiFunction[T, U, R]

class FromJavaBiPredicate[T, U]

class FromJavaBinaryOperator[T]

class FromJavaDoubleBinaryOperator

class FromJavaIntBinaryOperator

class FromJavaLongBinaryOperator

class FromJavaObjDoubleConsumer[T]

class FromJavaObjIntConsumer[T]

class FromJavaObjLongConsumer[T]

class FromJavaToDoubleBiFunction[T, U]

class FromJavaToIntBiFunction[T, U]

class FromJavaToLongBiFunction[T, U]

class AbstractFunction2[T1, T2, R]

trait JFunction2$mcDDD$sp

trait JFunction2$mcDDI$sp

trait JFunction2$mcDDJ$sp

trait JFunction2$mcDID$sp

trait JFunction2$mcDII$sp

trait JFunction2$mcDIJ$sp

trait JFunction2$mcDJD$sp

trait JFunction2$mcDJI$sp

trait JFunction2$mcDJJ$sp

trait JFunction2$mcFDD$sp

trait JFunction2$mcFDI$sp

trait JFunction2$mcFDJ$sp

trait JFunction2$mcFID$sp

trait JFunction2$mcFII$sp

trait JFunction2$mcFIJ$sp

trait JFunction2$mcFJD$sp

trait JFunction2$mcFJI$sp

trait JFunction2$mcFJJ$sp

trait JFunction2$mcIDD$sp

trait JFunction2$mcIDI$sp

trait JFunction2$mcIDJ$sp

trait JFunction2$mcIID$sp

trait JFunction2$mcIII$sp

trait JFunction2$mcIIJ$sp

trait JFunction2$mcIJD$sp

trait JFunction2$mcIJI$sp

trait JFunction2$mcIJJ$sp

trait JFunction2$mcJDD$sp

trait JFunction2$mcJDI$sp

trait JFunction2$mcJDJ$sp

trait JFunction2$mcJID$sp

trait JFunction2$mcJII$sp

trait JFunction2$mcJIJ$sp

trait JFunction2$mcJJD$sp

trait JFunction2$mcJJI$sp

trait JFunction2$mcJJJ$sp

trait JFunction2$mcVDD$sp

trait JFunction2$mcVDI$sp

trait JFunction2$mcVDJ$sp

trait JFunction2$mcVID$sp

trait JFunction2$mcVII$sp

trait JFunction2$mcVIJ$sp

trait JFunction2$mcVJD$sp

trait JFunction2$mcVJI$sp

trait JFunction2$mcVJJ$sp

trait JFunction2$mcZDD$sp

trait JFunction2$mcZDI$sp

trait JFunction2$mcZDJ$sp

trait JFunction2$mcZID$sp

trait JFunction2$mcZII$sp

trait JFunction2$mcZIJ$sp

trait JFunction2$mcZJD$sp

trait JFunction2$mcZJI$sp

trait JFunction2$mcZJJ$sp

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) => R

class AbstractFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) => R

class AbstractFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) => R

class AbstractFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R]

trait (T1, T2, T3) => R

class AbstractFunction3[T1, T2, T3, R]

trait (T1, T2, T3, T4) => R

class AbstractFunction4[T1, T2, T3, T4, R]

trait (T1, T2, T3, T4, T5) => R

class AbstractFunction5[T1, T2, T3, T4, T5, R]

trait (T1, T2, T3, T4, T5, T6) => R

class AbstractFunction6[T1, T2, T3, T4, T5, T6, R]

trait (T1, T2, T3, T4, T5, T6, T7) => R

class AbstractFunction7[T1, T2, T3, T4, T5, T6, T7, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8) => R

class AbstractFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R]

trait (T1, T2, T3, T4, T5, T6, T7, T8, T9) => R

class AbstractFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]

Value members

Concrete methods

Tests whether the argument (that) is a reference to the receiver object (this).

Tests whether the argument (that) is a reference to the receiver object (this).

The eq method implements an equivalence relation on non-null instances of AnyRef, and has three additional properties:

It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of x.eq(y) consistently returns true or consistently returns false.
For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.
null.eq(null) returns true.

When overriding the equals or hashCode methods, it is important to ensure that their behavior is consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).

Value Params

that: the object to compare against this object for reference equality.

Returns

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

Equivalent to !(this eq that).

Equivalent to !(this eq that).

Value Params

that: the object to compare against this object for reference equality.

Returns

true if the argument is not a reference to the receiver object; false otherwise.

Wakes up a single thread that is waiting on the receiver object's monitor.

Wakes up a single thread that is waiting on the receiver object's monitor.

Note: not specified by SLS as a member of AnyRef

Wakes up all threads that are waiting on the receiver object's monitor.

Wakes up all threads that are waiting on the receiver object's monitor.

Note: not specified by SLS as a member of AnyRef

Executes the code in body with an exclusive lock on this.

Executes the code in body with an exclusive lock on this.

Value Params

body: the code to execute

Returns

the result of body

See https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait--.

See https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait--.

Note: not specified by SLS as a member of AnyRef

See https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-.

See https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-.

Value Params

timeout: the maximum time to wait in milliseconds.

Note

not specified by SLS as a member of AnyRef

See https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-int-

See https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#wait-long-int-

Value Params

nanos: additional time, in nanoseconds range 0-999999.
timeout: the maximum time to wait in milliseconds.

Note

not specified by SLS as a member of AnyRef