in root-page
package scala

package scala

Field Summary
  type AnyRef

Object Summary
  object Console
     The Console object implements functionality for printing Scala values on the terminal.
  object Iterable
  object Iterator
     The Iterator object provides various functions for creating specialized iterators.
  object List
     This object provides methods for creating specialized lists, and for transforming special kinds of lists (e.g.
case object Nil
     The empty list.
case object None
     This case object represents non-existent values.
  object Predef
     The Predef object provides definitions that are accessible in all Scala compilation units without explicit qualification.
  object Seq
  object Stream
     The object Stream provides helper functions to manipulate streams.

Trait Summary
  trait BufferedIterator[+A]()
     Buffered iterators are iterators which allow to inspect the next element without discarding it.
  trait CaseClass()
     defines an access function for instances of case classes
  trait Function0[+R]()
  trait Function1[-T0,+R]()
  trait Function2[-T0,-T1,+R]()
  trait Function3[-T0,-T1,-T2,+R]()
  trait Function4[-T0,-T1,-T2,-T3,+R]()
  trait Function5[-T0,-T1,-T2,-T3,-T4,+R]()
  trait Function6[-T0,-T1,-T2,-T3,-T4,-T5,+R]()
  trait Function7[-T0,-T1,-T2,-T3,-T4,-T5,-T6,+R]()
  trait Function8[-T0,-T1,-T2,-T3,-T4,-T5,-T6,-T7,+R]()
  trait Function9[-T0,-T1,-T2,-T3,-T4,-T5,-T6,-T7,-T8,+R]()
  trait Iterable[+A]()
     Collection classes supporting this trait provide a method elements which returns an iterator over all the elements contained in the collection.
  trait IterableProxy[+A]()
     This class implements a proxy for iterable objects.
  trait Iterator[+A]()
     Iterators are data structures that allow to iterate over a sequence of elements.
  trait Option[+A]()
     This class represents optional values.
  trait Ordered[+a]()
     A trait for totally ordered data.
  trait PartialFunction[-A,+B]()
     A partial function of type PartialFunction[A, B] is a unary function where the domain does not include all values of type A.
  trait PartiallyOrdered[+a]()
     A trait for partially ordered data.
  trait Proxy()
     This class implements a simple proxy that forwards all calls to methods of class Any to another object self.
  trait ScalaObject()
  trait Seq[+A]()
     Class Seq[A] represents finite sequences of elements of type A.
  trait SeqProxy[+A]()
     Class Seq[A] represents finite sequences of elements of type A.
  trait Stream[+a]()
    

The class Stream implements lazy lists where elements are only evaluated when they are needed.


Class Summary
final case class ::[+b](hd: b, tl: List[b])
     A non empty list characterized by a head and a tail.
abstract final class All()
abstract final class AllRef()
  class Any()
abstract class AnyVal()
  class Application()
     The Application class can be used to quickly turn objects into executable programs.
abstract class Array[T](x0: Int)
  class Attribute()
     A base class for attributes
abstract class Boolean(x0: Boolean)
abstract class Byte(x0: Byte)
case class Cell[+T](elem: T)
     A Cell is a generic wrapper which completely hides the functionality of the wrapped object.
abstract class Char(x0: Char)
abstract class Double(x0: Double)
abstract class Enumeration(initial: Int, names: String*)
    

The class Enumeration provides the same functionality as the enum construct found in C-like languages like C++ or Java.

abstract class Float(x0: Float)
abstract class Int(x0: Int)
abstract sealed class List[+a]()
     A trait representing an ordered collection of elements of type a.
abstract class Long(x0: Long)
case class SerialVersionUID(uid: Long)
abstract class Short(x0: Short)
final case class Some[+A1](x: A1)
     Class Option[A] represents existing values of type A.
final case class Symbol(name: String)
     Instances of Symbol can be created easily with Scala's built-in quote mechanism.
case class Tuple1[+T1](_1: T1)
case class Tuple2[+T1,+T2](_1: T1, _2: T2)
case class Tuple3[+T1,+T2,+T3](_1: T1, _2: T2, _3: T3)
case class Tuple4[+T1,+T2,+T3,+T4](_1: T1, _2: T2, _3: T3, _4: T4)
case class Tuple5[+T1,+T2,+T3,+T4,+T5](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5)
case class Tuple6[+T1,+T2,+T3,+T4,+T5,+T6](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6)
case class Tuple7[+T1,+T2,+T3,+T4,+T5,+T6,+T7](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7)
case class Tuple8[+T1,+T2,+T3,+T4,+T5,+T6,+T7,+T8](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8)
case class Tuple9[+T1,+T2,+T3,+T4,+T5,+T6,+T7,+T8,+T9](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9)
abstract class Unit()
  class _trait_()
     Temporary class.
  class cloneable()
  class serializable()
  class transient()
  class volatile()

Package Summary
  package collection
  package concurrent
  package io
  package mobile
  package reflect
  package runtime
  package testing
  package text
  package util
  package xml

Field Detail

AnyRef

  type AnyRef = Object