spark.repl.SparkIMain

Instance Constructors

new SparkIMain()
new SparkIMain(settings: Settings)

construct an interpreter that reports to Console
new SparkIMain(settings: Settings, out: PrintWriter)

Type Members

case class ComputedImports(prepend: String, append: String, access: String) extends Product with Serializable

Compute imports that allow definitions from previous requests to be visible in a new request.
class ReadEvalPrint extends AnyRef

Here is where we:
class Request extends AnyRef

One line of code submitted by the user for interpretation

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def DBG(s: ⇒ String): Unit
val SPARK_DEBUG_REPL: Boolean
def addImports(ids: String*): Result
def afterTyper[T](op: ⇒ T): T
def aliasForType(path: String): Option[String]

Parse the ScalaSig to find type aliases
def allDefinedNames: List[Name]
def allImplicits: List[Name]
def allSeenTypes: List[String]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def atPickler[T](op: ⇒ T): T
def beQuietDuring[T](operation: ⇒ T): T

Temporarily be quiet
def beSilentDuring[T](operation: ⇒ T): T
def bind[T](name: String, value: T)(implicit arg0: Manifest[T]): Result
def bind(p: NamedParam): Result
def bind(name: String, boundType: String, value: Any): Result

Bind a specified name to a specified value.
Bind a specified name to a specified value. The name may later be used by expressions passed to interpret.
name
the variable name to bind
boundType
the type of the variable, as a string
value
the object value to bind to it
returns
an indication of whether the binding succeeded
def bindValue(x: Any): Result
def classLoader: AbstractFileClassLoader
def classOfTerm(id: String): Option[JClass]
val classServer: HttpServer

Jetty server that will serve our classes to worker nodes
def clearExecutionWrapper(): Unit
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def close(): Unit

This instance is no longer needed, so release any resources it is using.
This instance is no longer needed, so release any resources it is using. The reporter's output gets flushed.
def compileSources(sources: SourceFile*): Boolean

Compile an nsc SourceFile.
Compile an nsc SourceFile. Returns true if there are no compilation errors, or false otherwise.
def compileString(code: String): Boolean

Compile a string.
Compile a string. Returns true if there are no compilation errors, or false otherwise.
lazy val compilerClasspath: List[URL]

the compiler's classpath, as URL's
def createLineManager(): Manager

Attributes
protected
def debugging[T](msg: String)(res: T): T
def definedSymbols: Set[Symbol]
def definedTerms: List[TermName]
def definedTypes: List[TypeName]
def definitionForName(name: Name): Option[MemberHandler]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def executionWrapper: String
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def flatName(id: 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.
Given a simple repl-defined name, returns the real name of the class representing it, e.g. for "Bippy" it may return
$line19.$read$$iw$$iw$$iw$$iw$$iw$$iw$$iw$$iw$Bippy
final def getClass(): java.lang.Class[_]

Definition Classes
AnyRef → Any
def getInterpreterClassLoader(): AbstractFileClassLoader
lazy val global: Global

the public, go through the future compiler
def handleTermRedefinition(name: TermName, old: Request, req: Request): Unit
def handleTypeRedefinition(name: TypeName, old: Request, req: Request): Unit

Stubs for work in progress.
def hashCode(): Int

Definition Classes
AnyRef → Any
def implicitSymbols: List[Symbol]

Definition Classes
SparkImports
def implicitSymbolsBySource: List[(Symbol, List[Symbol])]

Definition Classes
SparkImports
def importHandlers: List[ImportHandler]
def importedSymbols: List[Symbol]

Definition Classes
SparkImports
def importedSymbolsBySource: List[(Symbol, List[Symbol])]

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

Definition Classes
SparkImports
def importedTermNamed(name: String): Option[TermSymbol]

Definition Classes
SparkImports
def importedTermSymbols: List[TermSymbol]

Definition Classes
SparkImports
def importedTerms: List[TermName]

Definition Classes
SparkImports
def importedTypeSymbols: List[TypeSymbol]

Definition Classes
SparkImports
def importedTypes: List[TypeName]

Definition Classes
SparkImports
def importsCode(wanted: Set[Name]): ComputedImports

Attributes
protected
Definition Classes
SparkImports
def initialize(): Unit
def interpret(line: String, synthetic: Boolean): Result
def interpret(line: String): Result

Interpret one line of input.
Interpret one line of input. All feedback, including parse errors and evaluation results, are printed via the supplied compiler's reporter. Values defined are available for future interpreted strings.
The return value is whether the line was interpreter successfully, e.g. that there were no parse errors.
line
...
returns
...
def isInitializeComplete: Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isParseable(line: String): Boolean
lazy val isettings: SparkISettings

interpreter settings
def languageSymbols: List[Symbol]

Definition Classes
SparkImports
def languageWildcardHandlers: List[ImportHandler]

Definition Classes
SparkImports
def languageWildcardSyms: List[Symbol]

Symbols whose contents are language-defined to be imported.
Symbols whose contents are language-defined to be imported.

Definition Classes
SparkImports
def languageWildcards: List[Type]

Definition Classes
SparkImports
lazy val lineManager: Manager
lazy val memberHandlers: SparkMemberHandlers { val intp: SparkIMain.this.type }
def mostRecentVar: String

Returns the name of the most recent interpreter result.
Returns the name of the most recent interpreter result. Mostly this exists so you can conveniently invoke methods on the previous result.
object naming extends Naming
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newCompiler(settings: Settings, reporter: Reporter): Global

Instantiate a compiler.
Instantiate a compiler. Subclasses can override this to change the compiler class used by this interpreter.

Attributes
protected
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onlyTerms(xs: List[Name]): List[TermName]

Attributes
protected
def onlyTypes(xs: List[Name]): List[TypeName]

Attributes
protected
def optFlatName(id: String): Option[String]
val out: PrintWriter

Attributes
protected
val outputDir: File

Local directory to save .
Local directory to save .class files too
def parentClassLoader: ClassLoader

Attributes
protected
def parse(line: String): Option[List[Tree]]

Parse a line into a sequence of trees.
Parse a line into a sequence of trees. Returns None if the input is incomplete.
def pathToName(name: Name): String
def pathToTerm(id: String): String
def pathToType(id: String): String
def prevRequestList: List[Request]

Attributes
protected
var printResults: Boolean

whether to print out result lines
def quietBind(p: NamedParam): Result
def quietImport(ids: String*): Result
def quietRun[T](code: String): Result
def rebind(p: NamedParam): Result
def recordRequest(req: Request): Unit
lazy val reporter: ConsoleReporter

reporter
def reset(): Unit

Reset this interpreter, forgetting all user-specified requests.
def resetClassLoader(): Unit
def runtimeClassAndTypeOfTerm(id: String): Option[(JClass, Type)]
def runtimeTypeOfTerm(id: String): Option[Type]
def safeClass(name: String): Option[Symbol]
def safeModule(name: String): Option[Symbol]
def sessionImportedSymbols: List[Symbol]

Definition Classes
SparkImports
def sessionWildcards: List[Type]

Types which have been wildcard imported, such as: val x = "abc" ; import x.
Types which have been wildcard imported, such as: val x = "abc" ; import x._ // type java.lang.String import java.lang.String._ // object java.lang.String
Used by tab completion.
XXX right now this gets import x._ and import java.lang.String._, but doesn't figure out import String._. There's a lot of ad hoc scope twiddling which should be swept away in favor of digging into the compiler scopes.

Definition Classes
SparkImports
def setContextClassLoader(): Unit
def setExecutionWrapper(code: String): Unit
val settings: Settings
def showCodeIfDebugging(code: String): Unit
def symbolDefString(sym: Symbol): String
def symbolOfTerm(id: String): Symbol
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
var totalSilence: Boolean

whether to print errors
def typeOfExpression(expr: String): Option[Type]
def typeOfTerm(id: String): Option[Type]
def unqualifiedIds: List[String]

Another entry point for tab-completion, ids in scope
def valueOfTerm(id: String): Option[AnyRef]
val virtualDirectory: PlainFile

Scala compiler virtual directory for outputDir
def visibleTermNames: List[Name]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()
def wildcardTypes: List[Type]

Definition Classes
SparkImports
def withoutBindingLastException[T](operation: ⇒ T): T

Temporarily stop binding lastException
def withoutUnwrapping(op: ⇒ Unit): Unit

Deprecated Value Members

lazy val compiler: SparkIMain.this.global.type

Annotations
@deprecated
Deprecated
(Since version 2.9.0) Use global for access to the compiler instance.

SparkIMain

class SparkIMain extends SparkImports

Instance Constructors

new SparkIMain()

new SparkIMain(settings: Settings)

new SparkIMain(settings: Settings, out: PrintWriter)

Type Members

case class ComputedImports(prepend: String, append: String, access: String) extends Product with Serializable

class ReadEvalPrint extends AnyRef

class Request extends AnyRef

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def DBG(s: ⇒ String): Unit

val SPARK_DEBUG_REPL: Boolean

def addImports(ids: String*): Result

def afterTyper[T](op: ⇒ T): T

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

def allDefinedNames: List[Name]

def allImplicits: List[Name]

def allSeenTypes: List[String]

final def asInstanceOf[T0]: T0

def atPickler[T](op: ⇒ T): T

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

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

def bind[T](name: String, value: T)(implicit arg0: Manifest[T]): Result

def bind(p: NamedParam): Result

def bind(name: String, boundType: String, value: Any): Result

def bindValue(x: Any): Result

def classLoader: AbstractFileClassLoader

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

val classServer: HttpServer

def clearExecutionWrapper(): Unit

def clone(): AnyRef

def close(): Unit

def compileSources(sources: SourceFile*): Boolean

def compileString(code: String): Boolean

lazy val compilerClasspath: List[URL]

def createLineManager(): Manager

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

def definedSymbols: Set[Symbol]

def definedTerms: List[TermName]

def definedTypes: List[TypeName]

def definitionForName(name: Name): Option[MemberHandler]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executionWrapper: String

def finalize(): Unit

def flatName(id: String): String

lazy val formatting: Formatting

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

final def getClass(): java.lang.Class[_]

def getInterpreterClassLoader(): AbstractFileClassLoader

lazy val global: Global

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

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

def hashCode(): Int

def implicitSymbols: List[Symbol]

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

def importHandlers: List[ImportHandler]

def importedSymbols: List[Symbol]

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

def importedTermNamed(name: String): Option[TermSymbol]

def importedTermSymbols: List[TermSymbol]

def importedTerms: List[TermName]

def importedTypeSymbols: List[TypeSymbol]

def importedTypes: List[TypeName]

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

def initialize(): Unit

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

def interpret(line: String): Result

def isInitializeComplete: Boolean

final def isInstanceOf[T0]: Boolean

def isParseable(line: String): Boolean

lazy val isettings: SparkISettings

def languageSymbols: List[Symbol]

def languageWildcardHandlers: List[ImportHandler]