Showing content from https://www.scala-lang.org/api/2.11.12/scala-compiler/scala/tools/ant/sabbus/Compilers$.html below:
Compilers - Scala Compiler 2.11.12
final def !=(arg0: Any): Boolean
final def ##(): Int
def +[B1 >: Compiler](kv: (String, B1)): Map[String, B1]
def +[B1 >: Compiler](kv1: (String, B1), kv2: (String, B1), kvs: (String, B1)*): Map[String, B1]
def ++[B1 >: Compiler](xs: GenTraversableOnce[(String, B1)]): Map[String, B1]
def ++[B >: (String, Compiler), That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Map[String, Compiler], B, That]): That
def ++:[B >: (String, Compiler), That](that: collection.Traversable[B])(implicit bf: CanBuildFrom[Map[String, Compiler], B, That]): That
def ++:[B >: (String, Compiler), That](that: collection.TraversableOnce[B])(implicit bf: CanBuildFrom[Map[String, Compiler], B, That]): That
def -(key: String): Map[String, Compiler]
def -(elem1: String, elem2: String, elems: String*): Map[String, Compiler]
def --(xs: GenTraversableOnce[String]): Map[String, Compiler]
def /:[B](z: B)(op: (B, (String, Compiler)) â B): B
def :\[B](z: B)(op: ((String, Compiler), B) â B): B
final def ==(arg0: Any): Boolean
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder
def addString(b: StringBuilder): StringBuilder
def addString(b: StringBuilder, sep: String): StringBuilder
def aggregate[B](z: â B)(seqop: (B, (String, Compiler)) â B, combop: (B, B) â B): B
def andThen[C](k: (Compiler) â C): PartialFunction[String, C]
def apply(key: String): Compiler
def applyOrElse[A1 <: String, B1 >: Compiler](x: A1, default: (A1) â B1): B1
final def asInstanceOf[T0]: T0
def break(id: String): Null
def canEqual(that: Any): Boolean
def clone(): AnyRef
def collect[B, That](pf: PartialFunction[(String, Compiler), B])(implicit bf: CanBuildFrom[Map[String, Compiler], B, That]): That
def collectFirst[B](pf: PartialFunction[(String, Compiler), B]): Option[B]
def companion: GenericCompanion[collection.Iterable]
def compose[A](g: (A) â String): (A) â Compiler
def contains(key: String): Boolean
def copyToArray[B >: (String, Compiler)](xs: Array[B], start: Int, len: Int): Unit
def copyToArray[B >: (String, Compiler)](xs: Array[B]): Unit
def copyToArray[B >: (String, Compiler)](xs: Array[B], start: Int): Unit
def copyToBuffer[B >: (String, Compiler)](dest: Buffer[B]): Unit
def count(p: ((String, Compiler)) â Boolean): Int
val debug: Boolean
def default(key: String): Compiler
def drop(n: Int): Map[String, Compiler]
def dropRight(n: Int): Map[String, Compiler]
def dropWhile(p: ((String, Compiler)) â Boolean): Map[String, Compiler]
def empty: Map[String, Compiler]
final def eq(arg0: AnyRef): Boolean
def equals(that: Any): Boolean
def exists(p: ((String, Compiler)) â Boolean): Boolean
def filter(p: ((String, Compiler)) â Boolean): Map[String, Compiler]
def filterKeys(p: (String) â Boolean): Map[String, Compiler]
def filterNot(p: ((String, Compiler)) â Boolean): Map[String, Compiler]
def finalize(): Unit
def find(p: ((String, Compiler)) â Boolean): Option[(String, Compiler)]
def flatMap[B, That](f: ((String, Compiler)) â GenTraversableOnce[B])(implicit bf: CanBuildFrom[Map[String, Compiler], B, That]): That
def flatten[B](implicit asTraversable: ((String, Compiler)) â GenTraversableOnce[B]): collection.Iterable[B]
def fold[A1 >: (String, Compiler)](z: A1)(op: (A1, A1) â A1): A1
def foldLeft[B](z: B)(op: (B, (String, Compiler)) â B): B
def foldRight[B](z: B)(op: ((String, Compiler), B) â B): B
def forall(p: ((String, Compiler)) â Boolean): Boolean
def foreach[U](f: ((String, Compiler)) â U): Unit
def genericBuilder[B]: Builder[B, collection.Iterable[B]]
def get(id: String): Option[Compiler]
final def getClass(): Class[_]
def getOrElse[B1 >: Compiler](key: String, default: â B1): B1
def groupBy[K](f: ((String, Compiler)) â K): Map[K, Map[String, Compiler]]
def grouped(size: Int): collection.Iterator[Map[String, Compiler]]
def hasDefiniteSize: Boolean
def hashCode(): Int
def head: (String, Compiler)
def headOption: Option[(String, Compiler)]
def init: Map[String, Compiler]
def inits: collection.Iterator[Map[String, Compiler]]
def isDefinedAt(key: String): Boolean
def isEmpty: Boolean
final def isInstanceOf[T0]: Boolean
final def isTraversableAgain: Boolean
def iterator: collection.Iterator[(String, Compiler)]
def keySet: Set[String]
def keys: collection.Iterable[String]
def keysIterator: collection.Iterator[String]
def last: (String, Compiler)
def lastOption: Option[(String, Compiler)]
def lift: (String) â Option[Compiler]
def make(id: String, classpath: Array[URL], settings: Settings): Compiler
def map[B, That](f: ((String, Compiler)) â B)(implicit bf: CanBuildFrom[Map[String, Compiler], B, That]): That
def mapValues[C](f: (Compiler) â C): Map[String, C]
def max[B >: (String, Compiler)](implicit cmp: Ordering[B]): (String, Compiler)
def maxBy[B](f: ((String, Compiler)) â B)(implicit cmp: Ordering[B]): (String, Compiler)
def min[B >: (String, Compiler)](implicit cmp: Ordering[B]): (String, Compiler)
def minBy[B](f: ((String, Compiler)) â B)(implicit cmp: Ordering[B]): (String, Compiler)
def mkString: String
def mkString(sep: String): String
def mkString(start: String, sep: String, end: String): String
final def ne(arg0: AnyRef): Boolean
def newBuilder: Builder[(String, Compiler), Map[String, Compiler]]
def nonEmpty: Boolean
final def notify(): Unit
final def notifyAll(): Unit
def orElse[A1 <: String, B1 >: Compiler](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
def par: ParMap[String, Compiler]
def parCombiner: Combiner[(String, Compiler), ParMap[String, Compiler]]
def partition(p: ((String, Compiler)) â Boolean): (Map[String, Compiler], Map[String, Compiler])
def product[B >: (String, Compiler)](implicit num: Numeric[B]): B
def reduce[A1 >: (String, Compiler)](op: (A1, A1) â A1): A1
def reduceLeft[B >: (String, Compiler)](op: (B, (String, Compiler)) â B): B
def reduceLeftOption[B >: (String, Compiler)](op: (B, (String, Compiler)) â B): Option[B]
def reduceOption[A1 >: (String, Compiler)](op: (A1, A1) â A1): Option[A1]
def reduceRight[B >: (String, Compiler)](op: ((String, Compiler), B) â B): B
def reduceRightOption[B >: (String, Compiler)](op: ((String, Compiler), B) â B): Option[B]
def repr: Map[String, Compiler]
def reversed: List[(String, Compiler)]
def runWith[U](action: (Compiler) â U): (String) â Boolean
def sameElements[B >: (String, Compiler)](that: GenIterable[B]): Boolean
def scan[B >: (String, Compiler), That](z: B)(op: (B, B) â B)(implicit cbf: CanBuildFrom[Map[String, Compiler], B, That]): That
def scanLeft[B, That](z: B)(op: (B, (String, Compiler)) â B)(implicit bf: CanBuildFrom[Map[String, Compiler], B, That]): That
def scanRight[B, That](z: B)(op: ((String, Compiler), B) â B)(implicit bf: CanBuildFrom[Map[String, Compiler], B, That]): That
def seq: Map[String, Compiler]
def size: Int
def slice(from: Int, until: Int): Map[String, Compiler]
def sliding(size: Int, step: Int): collection.Iterator[Map[String, Compiler]]
def sliding(size: Int): collection.Iterator[Map[String, Compiler]]
def span(p: ((String, Compiler)) â Boolean): (Map[String, Compiler], Map[String, Compiler])
def splitAt(n: Int): (Map[String, Compiler], Map[String, Compiler])
def stringPrefix: String
def sum[B >: (String, Compiler)](implicit num: Numeric[B]): B
final def synchronized[T0](arg0: â T0): T0
def tail: Map[String, Compiler]
def tails: collection.Iterator[Map[String, Compiler]]
def take(n: Int): Map[String, Compiler]
def takeRight(n: Int): Map[String, Compiler]
def takeWhile(p: ((String, Compiler)) â Boolean): Map[String, Compiler]
def thisCollection: collection.Iterable[(String, Compiler)]
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, (String, Compiler), Col[(String, Compiler)]]): Col[(String, Compiler)]
def toArray[B >: (String, Compiler)](implicit arg0: ClassTag[B]): Array[B]
def toBuffer[C >: (String, Compiler)]: Buffer[C]
def toCollection(repr: Map[String, Compiler]): collection.Iterable[(String, Compiler)]
def toIndexedSeq: collection.immutable.IndexedSeq[(String, Compiler)]
def toIterable: collection.Iterable[(String, Compiler)]
def toIterator: collection.Iterator[(String, Compiler)]
def toList: List[(String, Compiler)]
def toMap[T, U](implicit ev: <:<[(String, Compiler), (T, U)]): Map[T, U]
def toSeq: collection.Seq[(String, Compiler)]
def toSet[B >: (String, Compiler)]: Set[B]
def toStream: collection.immutable.Stream[(String, Compiler)]
def toString(): String
def toTraversable: collection.Traversable[(String, Compiler)]
def toVector: Vector[(String, Compiler)]
def transpose[B](implicit asTraversable: ((String, Compiler)) â GenTraversableOnce[B]): collection.Iterable[collection.Iterable[B]]
def unzip[A1, A2](implicit asPair: ((String, Compiler)) â (A1, A2)): (collection.Iterable[A1], collection.Iterable[A2])
def unzip3[A1, A2, A3](implicit asTriple: ((String, Compiler)) â (A1, A2, A3)): (collection.Iterable[A1], collection.Iterable[A2], collection.Iterable[A3])
def updated[B1 >: Compiler](key: String, value: B1): Map[String, B1]
def values: collection.Iterable[Compiler]
def valuesIterator: collection.Iterator[Compiler]
def view(from: Int, until: Int): IterableView[(String, Compiler), Map[String, Compiler]]
def view: IterableView[(String, Compiler), Map[String, Compiler]]
final def wait(): Unit
final def wait(arg0: Long, arg1: Int): Unit
final def wait(arg0: Long): Unit
def withFilter(p: ((String, Compiler)) â Boolean): FilterMonadic[(String, Compiler), Map[String, Compiler]]
def zip[A1 >: (String, Compiler), B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Map[String, Compiler], (A1, B), That]): That
def zipAll[B, A1 >: (String, Compiler), That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Map[String, Compiler], (A1, B), That]): That
def zipWithIndex[A1 >: (String, Compiler), That](implicit bf: CanBuildFrom[Map[String, Compiler], (A1, Int), That]): That
RetroSearch is an open source project built by @garambo
| Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4