abstract defassociatedFile: AbstractFile

Source file if this symbol is created during this compilation run,
or a class file if this symbol is loaded from a *.

Source file if this symbol is created during this compilation run,
or a class file if this symbol is loaded from a *.class or *.jar.

The return type is scala.reflect.io.AbstractFile, which belongs to an experimental part of Scala reflection.
It should not be used unless you know what you are doing. In subsequent releases, this API will be refined
and exposed as a part of scala.reflect.api.

Filters the underlying alternatives (or a single-element list
composed of the symbol itself if the symbol is not overloaded).

Filters the underlying alternatives (or a single-element list
composed of the symbol itself if the symbol is not overloaded).
Returns an overloaded symbol is there are multiple matches.
Returns a NoSymbol if there are no matches.

Is this symbol static (i.e. with no outer instance)?
Q: When exactly is a sym marked as STATIC?
A: If it's a member of a toplevel object, or of an object contained in a toplevel object, or any number of levels deep.
http://groups.google.com/group/scala-internals/browse_thread/thread/d385bcd60b08faf6

All parameter lists of the method.
The name ending with "ss" indicates that the result type is a list of lists.

Can be used to distinguish nullary methods and methods with empty parameter lists.
For a nullary method, returns the empty list (i.e. List()).
For a method with an empty parameter list, returns a list that contains the empty list (i.e. List(List())).

Set when symbol has a modifier of the form private[X], NoSymbol otherwise.

Set when symbol has a modifier of the form private[X], NoSymbol otherwise.

Access level encoding: there are three scala flags (PRIVATE, PROTECTED,
and LOCAL) which combine with value privateWithin (the "foo" in private[foo])
to define from where an entity can be accessed. The meanings are as follows:

PRIVATE access restricted to class only.
PROTECTED access restricted to class and subclasses only.
LOCAL can only be set in conjunction with PRIVATE or PROTECTED.
Further restricts access to the same object instance.

In addition, privateWithin can be used to set a visibility barrier.
When set, everything contained in the named enclosing package or class
has access. It is incompatible with PRIVATE or LOCAL, but is additive
with PROTECTED (i.e. if either the flags or privateWithin allow access,
then it is allowed.)

This method always returns signatures in the most generic way possible, even if the underlying symbol is obtained from an
instantiation of a generic type. For example, signature
of the method def map[B](f: (A) ⇒ B): List[B], which refers to the type parameter A of the declaring class List[A],
will always feature A, regardless of whether map is loaded from the List[_] or from List[Int]. To get a signature
with type parameters appropriately instantiated, one should use typeSignatureIn.

Equivalent to x.hashCode except for boxed numeric types and null.
For numerics, it returns a hash value which is consistent
with value equality: if two value type instances compare
as true, then ## will produce the same hash value for each
of them.
For null returns a hashcode where null.hashCode throws a
NullPointerException.

final defasInstanceOf[T0]: T0

Cast the receiver object to be of type T0.

Cast the receiver object to be of type T0.

Note that the success of a cast at runtime is modulo Scala's erasure semantics.
Therefore the expression 1.asInstanceOf[String] will throw a ClassCastException at
runtime, while the expression List(1).asInstanceOf[List[String]] will not.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the requested type.

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

Tests whether the argument (arg0) 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).

returns

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

Note that the result of the test is modulo Scala's erasure semantics.
Therefore the expression 1.isInstanceOf[String] will return false, while the
expression List(1).isInstanceOf[List[String]] will return true.
In the latter example, because the type argument is erased as part of compilation it is
not possible to check whether the contents of the list are of the specified type.

returns

true if the receiver object is an instance of erasure of type T0; false otherwise.

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.

Definition Classes

AnyRef

Note

not specified by SLS as a member of AnyRef

final defsynchronized[T0](arg0: ⇒ T0): T0

Definition Classes

AnyRef

deftoString(): String

Creates a String representation of this object.

Creates a String representation of this object. The default
representation is platform dependent. On the java platform it
is the concatenation of the class name, "@", and the object's
hashcode in hexadecimal.