InterpreterLoop

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object LoopCommand

object Result extends Serializable

def addClasspath(arg: String): Unit

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

def addReplay(cmd: String): Unit

Record a command for replay should the user request a :replay

def addThunk(body: ⇒ Unit): Unit

var addedClasspath: String

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

Parse the ScalaSig to find type aliases

def allDefHandlers: (⇒collection.immutable.List[(interpreter.IMain._2612.type.memberHandlers)#MemberDefHandler]) forSome {val _2612: IMain}

def allDefSymbols: (⇒collection.immutable.List[Global.Symbol]) forSome {val _2618: IMain}

def allDefinedNames: (⇒collection.immutable.List[Global.Name]) forSome {val _2624: IMain}

def allHandlers: (⇒collection.immutable.List[(interpreter.IMain._2630.type.memberHandlers)#MemberHandler]) forSome {val _2630: IMain}

def allImplicits: (⇒collection.immutable.List[Global.Name { ... /* 5 definitions in type refinement */ }]) forSome {val _2636: IMain}

def allImportedNames: (⇒collection.immutable.List[Global.Name]) forSome {val _2642: IMain}

def allSeenTypes: collection.immutable.List[String]

def apply[T]: ([T](implicit evidence$7: scala.reflect.ClassTag[T])_2648.global.Symbol) forSome {val _2648: IMain}

def apply: ((name: String)_2654.global.Symbol) forSome {val _2654: IMain}

Translate a repl-defined identifier into a Symbol.

final def asInstanceOf[T0]: T0

def asyncEcho(async: Boolean, msg: ⇒ String): Unit

def asyncMessage(msg: String): Unit

def awaitInitialized(): Boolean

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]): interpreter.Results.Result

def bind(p: NamedParam): interpreter.Results.Result

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

Bind a specified name to a specified value.

def bindSyntheticValue(x: Any): interpreter.Results.Result

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

def bindValue(x: Any): interpreter.Results.Result

def chooseReader(settings: Settings): InteractiveReader

Tries to create a JLineReader, falling back to SimpleReader: unless settings or properties are such that it should start with SimpleReader.

def classLoader: AbstractFileClassLoader

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

def classSymbols: (⇒collection.immutable.List[Global.ClassSymbol]) forSome {val _2660: IMain}

def cleanMemberDecl: ((owner: _2666.global.Symbol, member: _2666.global.Name)_2666.global.Type) forSome {val _2666: IMain}

def clearExecutionWrapper(): Unit

def clone(): AnyRef

def close(): Unit

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

def closeInterpreter(): Unit

Close the interpreter and set the var to null.

def command(line: String): Result

Run one command submitted by the user.

def commands: List[LoopCommand]

Available commands

def compileSources(sources: SourceFile*): Boolean

Compile an nsc SourceFile.

def compileSourcesKeepingRun: ((sources: scala.reflect.internal.util.SourceFile*)(Boolean, _2672.global.Run)) forSome {val _2672: IMain}

def compileString(code: String): Boolean

Compile a string.

def compilerClasspath: Seq[URL]

def createAsyncListener(): Future[Unit]

def createInterpreter(): Unit

Create a new interpreter.

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

def definedSymbolList: (⇒collection.immutable.List[Global.Symbol]) forSome {val _2678: IMain}

def definedSymbols: (⇒Set[Global.Symbol]) forSome {val _2684: IMain}

def definedTerms: (⇒collection.immutable.List[Global.TermName]) forSome {val _2690: IMain}

def definedTypes: (⇒collection.immutable.List[Global.TypeName]) forSome {val _2696: IMain}

def definitionForName: ((name: _2702.global.Name)Option[_2702.memberHandlers.MemberHandler]) forSome {val _2702: IMain}

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

def directBind(p: NamedParam): interpreter.Results.Result

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

def echo(msg: String): Unit

def echoAndRefresh(msg: String): Unit

def echoCommandMessage(msg: String): Unit

def echoNoNL(msg: String): Unit

def enablePowerMode(isDuringInit: Boolean): Unit

final def ensureClassLoader(): Unit

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

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

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

def ensuring(cond: Boolean): InterpreterLoop

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executionWrapper: String

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: _2708.global.TermName, old: _2708.Request, req: _2708.Request)Unit) forSome {val _2708: IMain}

def handleTypeRedefinition: ((name: _2714.global.TypeName, old: _2714.Request, req: _2714.Request)Unit) forSome {val _2714: IMain}

Stubs for work in progress.

def hashCode(): Int

def helpCommand(line: String): Result

print a friendly help message

def history: History

lazy val historyCommand: LoopCommand { def defaultLines: Int }

Show the history

def implicitSymbols: (⇒collection.immutable.List[Global.Symbol]) forSome {val _2720: IMain}

def implicitSymbolsBySource: (⇒collection.immutable.List[(Global.Symbol, collection.immutable.List[Global.Symbol])]) forSome {val _2726: IMain}

def importHandlers: (⇒collection.immutable.List[(interpreter.IMain._2732.type.memberHandlers)#ImportHandler]) forSome {val _2732: IMain}

def importedSymbols: (⇒collection.immutable.List[Global.Symbol]) forSome {val _2738: IMain}

def importedSymbolsBySource: (⇒collection.immutable.List[(Global.Symbol, collection.immutable.List[Global.Symbol])]) forSome {val _2744: IMain}

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

def importedTermNamed: ((name: String)_2750.global.Symbol) forSome {val _2750: IMain}

def importedTermSymbols: (⇒collection.immutable.List[Global.TermSymbol]) forSome {val _2756: IMain}

def importedTerms: (⇒collection.immutable.List[Global.TermName]) forSome {val _2762: IMain}

def importedTypeSymbols: (⇒collection.immutable.List[Global.TypeSymbol]) forSome {val _2768: IMain}

def importedTypes: (⇒collection.immutable.List[Global.TypeName]) forSome {val _2774: IMain}

var in: InteractiveReader

def initialize(postInitSignal: ⇒ Unit): Unit

def initializeSynchronous(): Unit

def initializedCallback(): Unit

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

def interpret(line: String): interpreter.Results.Result

Interpret one line of input.

def interpretAllFrom(file: File): Unit

interpret all lines from a specified file

def interpretStartingWith(code: String): Option[String]

Interpret expressions starting with the first line.

def interpretSynthetic(line: String): interpreter.Results.Result

var intp: IMain

def isAsync: Boolean

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]) forSome {val _2780: IMain}

def languageWildcardHandlers: (⇒collection.immutable.List[(interpreter.Imports._2786.type.memberHandlers)#ImportHandler]) forSome {val _2786: IMain}

def languageWildcardSyms: (⇒collection.immutable.List[Global.Symbol]) forSome {val _2792: IMain}

Symbols whose contents are language-defined to be imported.

def languageWildcards: (⇒collection.immutable.List[Global.Type]) forSome {val _2798: IMain}

def lastRequest: Request

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

def loadCommand(arg: String): Result

def loadFiles(settings: Settings): Unit

def loop(): Unit

The main read-eval-print loop for the repl.

lazy val memberHandlers: MemberHandlers { val intp: scala.tools.nsc.interpreter.IMain }

def methodSymbols: (⇒collection.immutable.List[Global.MethodSymbol]) forSome {val _2818: IMain}

def mostRecentLine: String

def mostRecentVar: String

Returns the name of the most recent interpreter result.

def namedDefinedTerms: (⇒collection.immutable.List[Global.TermName]) forSome {val _2824: IMain}

final def ne(arg0: AnyRef): Boolean

def newJavap(): JavapClass

def normalizeNonPublic: ((tp: _2830.global.Type)_2830.global.Type) forSome {val _2830: IMain}

final def notify(): Unit

final def notifyAll(): Unit

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

val originalClassLoader: ClassLoader

The context class loader at the time this object was created

def parse: ((line: String)Option[List[_2836.global.Tree]]) forSome {val _2836: IMain}

def pasteCommand(): Result

def pathToName: ((name: _2842.global.Name)String) forSome {val _2842: IMain}

def pathToTerm(id: String): String

def pathToType(id: String): String

def postInitThunks: collection.immutable.List[() ⇒ Unit]

def postInitialization(): Unit

lazy val power: Power[StdReplVals]

def powerCmd(): Result

lazy val powerCommands: List[LoopCommand]

Power user commands

def prevRequestList: collection.immutable.List[Request]

def printWelcome(): Unit

Print a welcome message

def process(args: Array[String]): Boolean

process command-line arguments and do as they request

def process(settings: Settings): Boolean

def prompt: String

Prompt to print when awaiting input

def quietBind(p: NamedParam): interpreter.Results.Result

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

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

def rebind(p: NamedParam): interpreter.Results.Result

def recordRequest: ((req: _2854.Request)Unit) forSome {val _2854: IMain}

def replay(): Unit

create a new interpreter and replay the given commands

var replayCommandStack: List[String]

A reverse list of commands to replay if the user requests a :replay

def replayCommands: collection.immutable.List[String]

A list of commands to replay if the user requests a :replay

val replayQuestionMessage: String

lazy val repllog: Logger

lazy val reporter: ReplReporter

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

def requestForName: ((name: _2867.global.Name)Option[_2867.Request]) forSome {val _2867: IMain}

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

def requestHistoryForName: ((name: _2880.global.Name)List[_2880.Request]) forSome {val _2880: IMain}

def reset(): Unit

def resetClassLoader(): Unit

def resetCommand(): Unit

def runThunks(): Unit

def runtimeClassAndTypeOfTerm: ((id: String)Option[(Class[_], _2886.global.Type)]) forSome {val _2886: IMain}

def runtimeTypeOfTerm: ((id: String)_2892.global.Type) forSome {val _2892: IMain}

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

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

def searchHistory(_cmdline: String): Unit

Search the history

def sessionImportedSymbols: (⇒collection.immutable.List[Global.Symbol]) forSome {val _2898: IMain}

def sessionWildcards: (⇒collection.immutable.List[Global.Type]) forSome {val _2904: IMain}

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

def setContextClassLoader(): Unit

def setExecutionWrapper(code: String): Unit

def setPrompt(prompt: String): Unit

var settings: Settings

lazy val shCommand: LoopCommand

fork a shell and run a command

def showCodeIfDebugging(code: String): Unit

implicit def stabilizeIMain(intp: IMain): IMainOps[interpreter.ILoop.stabilizeIMain.intp.type]

lazy val standardCommands: collection.immutable.List[LoopCommand]

Standard commands *

def symbolDefString: ((sym: _2910.global.Symbol)String) forSome {val _2910: IMain}

def symbolOfLine: ((code: String)_2916.global.Symbol) forSome {val _2916: IMain}

def symbolOfTerm: ((id: String)_2922.global.Symbol) forSome {val _2922: IMain}

def symbolOfType: ((id: String)_2928.global.Symbol) forSome {val _2928: IMain}

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

def terms[T]: ([T](implicit evidence$6: scala.reflect.ClassTag[T])_2934.global.Symbol) forSome {val _2934: IMain}

def terms: ((name: String)_2940.global.Symbol) forSome {val _2940: IMain}

def toString(): String

def treesForRequestId: ((id: Int)List[_2946.global.Tree]) forSome {val _2946: IMain}

def typeOfExpression: ((expr: String, silent: Boolean)_2952.global.Type) forSome {val _2952: IMain}

def typeOfTerm: ((id: String)_2958.global.Type) forSome {val _2958: IMain}

def types[T]: ([T](implicit evidence$5: scala.reflect.ClassTag[T])_2964.global.Symbol) forSome {val _2964: IMain}

def types: ((name: String)_2970.global.Symbol) forSome {val _2970: IMain}

def unqualifiedIds: collection.immutable.List[String]

Another entry point for tab-completion, ids in scope

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

def verbosity(): Unit

val virtualDirectory: VirtualDirectory

Leading with the eagerly evaluated.

def visibleTermNames: (⇒collection.immutable.List[Global.Name]) forSome {val _2976: IMain}

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]) forSome {val _2982: IMain}

def withFile(filename: String)(action: (File) ⇒ Unit): Unit

def withoutUnwrapping(op: ⇒ Unit): Unit

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

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

def reset(): Unit

Reset this interpreter, forgetting all user-specified requests.

val self: Any

val self: Any

def settings: Settings

lazy val compiler: (⇒interpreter.IMain._2984.type.global.type) forSome {val _2984: IMain}

def interpreter: IMain

def interpreter_=(i: Interpreter): Unit

def main(settings: Settings): Unit

def x: InterpreterLoop

def x: InterpreterLoop