ILoopInterpreter

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (ILoopInterpreter, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addImports(ids: String*): Results.Result

def aliasForType(path: String): Option[String]

Parse the ScalaSig to find type aliases

def allDefHandlers: collection.immutable.List[(memberHandlers)#MemberDefHandler]

def allDefSymbols: collection.immutable.List[Global.Symbol]

def allDefinedNames: collection.immutable.List[Global.Name]

def allHandlers: collection.immutable.List[(memberHandlers)#MemberHandler]

def allImplicits: collection.immutable.List[Global.Name { ... /* 5 definitions in type refinement */ }]

def allImportedNames: collection.immutable.List[Global.Name]

def allSeenTypes: collection.immutable.List[String]

def apply[T](implicit arg0: ClassTag[T]): Global.Symbol

def apply(name: String): Global.Symbol

Translate a repl-defined identifier into a Symbol.

final def asInstanceOf[T0]: T0

def beQuietDuring[T](body: ⇒ T): T

Temporarily be quiet

def beSilentDuring[T](operation: ⇒ T): T

def bind[T](name: String, value: T)(implicit arg0: reflect.api.JavaUniverse.TypeTag[T], arg1: ClassTag[T]): Results.Result

def bind(p: NamedParam): Results.Result

def bind(name: String, boundType: String, value: Any, modifiers: List[String] = Nil): Results.Result

Bind a specified name to a specified value.

def bindSyntheticValue(x: Any): Results.Result

def bindValue(name: String, x: Any): Results.Result

def bindValue(x: Any): Results.Result

def classLoader: AbstractFileClassLoader

def classOfTerm(id: String): Option[JClass]

def classSymbols: collection.immutable.List[Global.ClassSymbol]

def cleanMemberDecl(owner: Global.Symbol, member: Global.Name): Global.Type

def clearExecutionWrapper(): Unit

def clone(): AnyRef

def close(): Unit

This instance is no longer needed, so release any resources it is using.

def compileSources(sources: SourceFile*): Boolean

Compile an nsc SourceFile.

def compileSourcesKeepingRun(sources: SourceFile*): (Boolean, Run)

def compileString(code: String): Boolean

Compile a string.

def compilerClasspath: Seq[URL]

def debugging[T](msg: String)(res: T): T

object deconstruct extends StructuredTypeStrings

def definedSymbolList: collection.immutable.List[Global.Symbol]

def definedSymbols: Set[Global.Symbol]

def definedTerms: collection.immutable.List[Global.TermName]

def definedTypes: collection.immutable.List[Global.TypeName]

def definitionForName(name: Global.Name): Option[(memberHandlers)#MemberHandler]

def directBind[T](name: String, value: T)(implicit arg0: reflect.api.JavaUniverse.TypeTag[T], arg1: ClassTag[T]): Results.Result

def directBind(p: NamedParam): Results.Result

def directBind(name: String, boundType: String, value: Any): Results.Result

final def ensureClassLoader(): Unit

def ensuring(cond: (ILoopInterpreter) ⇒ Boolean, msg: ⇒ Any): ILoopInterpreter

def ensuring(cond: (ILoopInterpreter) ⇒ Boolean): ILoopInterpreter

def ensuring(cond: Boolean, msg: ⇒ Any): ILoopInterpreter

def ensuring(cond: Boolean): ILoopInterpreter

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executionWrapper: String

object exprTyper extends ExprTyper

def finalize(): Unit

def flatName(id: String): String

def formatted(fmtstr: String): String

lazy val formatting: Formatting

def generatedName(simpleName: String): Option[String]

Given a simple repl-defined name, returns the real name of the class representing it, e.

$line19.$read$$iw$$iw$$iw$$iw$$iw$$iw$$iw$$iw$Bippy

final def getClass(): Class[_]

def getInterpreterClassLoader(): AbstractFileClassLoader

lazy val global: Global

the public, go through the future compiler

def handleTermRedefinition(name: Global.TermName, old: Request, req: Request): Unit

def handleTypeRedefinition(name: Global.TypeName, old: Request, req: Request): Unit

Stubs for work in progress.

def hashCode(): Int

def implicitSymbols: collection.immutable.List[Global.Symbol]

def implicitSymbolsBySource: List[(Global.Symbol, List[Global.Symbol])]

def importHandlers: collection.immutable.List[(memberHandlers)#ImportHandler]

def importedSymbols: collection.immutable.List[Global.Symbol]

def importedSymbolsBySource: List[(Global.Symbol, List[Global.Symbol])]

Tuples of (source, imported symbols) in the order they were imported.

def importedTermNamed(name: String): Global.Symbol

def importedTermSymbols: collection.immutable.List[Global.TermSymbol]

def importedTerms: collection.immutable.List[Global.TermName]

def importedTypeSymbols: collection.immutable.List[Global.TypeSymbol]

def importedTypes: collection.immutable.List[Global.TypeName]

def importsCode(wanted: Set[Global.Name]): ComputedImports

def initialize(postInitSignal: ⇒ Unit): Unit

def initializeSynchronous(): Unit

def interpret(line: String, synthetic: Boolean): Results.Result

def interpret(line: String): Results.Result

Interpret one line of input.

def interpretSynthetic(line: String): Results.Result

def isInitializeComplete: Boolean

final def isInstanceOf[T0]: Boolean

def isNoImports: Boolean

def isNoPredef: Boolean

def isParseable(line: String): Boolean

lazy val isettings: ISettings

interpreter settings

def languageSymbols: collection.immutable.List[Global.Symbol]

def languageWildcardHandlers: collection.immutable.List[(memberHandlers)#ImportHandler]

def languageWildcardSyms: List[Global.Symbol]

Symbols whose contents are language-defined to be imported.

def languageWildcards: List[Global.Type]

def lastRequest: Request

def lastWarnings: List[(Global.Position, String)]

lazy val memberHandlers: MemberHandlers { val intp: ILoopInterpreter.this.type }

def methodSymbols: collection.immutable.List[Global.MethodSymbol]

def mostRecentLine: String

def mostRecentVar: String

Returns the name of the most recent interpreter result.

def namedDefinedTerms: collection.immutable.List[Global.TermName]

object naming extends Naming

final def ne(arg0: AnyRef): Boolean

def newCompiler(settings: Settings, reporter: Reporter): ReplGlobal

Instantiate a compiler.

def normalizeNonPublic(tp: Global.Type): Global.Type

final def notify(): Unit

final def notifyAll(): Unit

def onlyTerms(xs: List[Global.Name]): collection.immutable.List[Global.TermName]

def onlyTypes(xs: List[Global.Name]): collection.immutable.List[Global.TypeName]

def optFlatName(id: String): Option[String]

val out: JPrintWriter

def parentClassLoader: ClassLoader

Parent classloader.

def parse(line: String): Option[List[Global.Tree]]

def pathToName(name: Global.Name): String

def pathToTerm(id: String): String

def pathToType(id: String): String

def prevRequestList: collection.immutable.List[Request]

def quietBind(p: NamedParam): Results.Result

def quietImport(ids: String*): Results.Result

def quietRun[T](code: String): Results.Result

def rebind(p: NamedParam): Results.Result

def recordRequest(req: Request): Unit

lazy val repllog: Logger

lazy val reporter: ReplReporter

def requestForIdent(line: String): Option[Request]

def requestForName(name: Global.Name): Option[Request]

def requestForReqId(id: Int): Option[Request]

def requestHistoryForName(name: Global.Name): List[Request]

def reset(): Unit

Reset this interpreter, forgetting all user-specified requests.

def resetClassLoader(): Unit

def runtimeClassAndTypeOfTerm(id: String): Option[(JClass, Global.Type)]

def runtimeTypeOfTerm(id: String): Global.Type

def sessionImportedSymbols: collection.immutable.List[Global.Symbol]

def sessionWildcards: List[Global.Type]

Types which have been wildcard imported, such as: val x = "abc" ; import x.

def setContextClassLoader(): Unit

def setExecutionWrapper(code: String): Unit

def settings: Settings

def showCodeIfDebugging(code: String): Unit

def symbolDefString(sym: Global.Symbol): String

def symbolOfLine(code: String): Global.Symbol

def symbolOfTerm(id: String): Global.Symbol

def symbolOfType(id: String): Global.Symbol

final def synchronized[T0](arg0: ⇒ T0): T0

def terms[T](implicit arg0: ClassTag[T]): Global.Symbol

def terms(name: String): Global.Symbol

def toString(): String

def treesForRequestId(id: Int): List[Global.Tree]

def typeOfExpression(expr: String, silent: Boolean = true): Global.Type

def typeOfTerm(id: String): Global.Type

def types[T](implicit arg0: ClassTag[T]): Global.Symbol

def types(name: String): Global.Symbol

def unqualifiedIds: collection.immutable.List[String]

Another entry point for tab-completion, ids in scope

def valueOfTerm(id: String): Option[AnyRef]

val virtualDirectory: VirtualDirectory

Leading with the eagerly evaluated.

def visibleTermNames: List[Global.Name]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def wildcardTypes: collection.immutable.List[Global.Type]

def withoutUnwrapping(op: ⇒ Unit): Unit

def withoutWarnings[T](body: ⇒ T): T

def →[B](y: B): (ILoopInterpreter, B)

val self: Any

val self: Any

lazy val compiler: global.type

def x: ILoopInterpreter

def x: ILoopInterpreter