Need help with spores?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

heathermiller
128 Stars 24 Forks Other 113 Commits 10 Opened issues

Description

Scala Spores, safe mobile closures.

Services available

!
?

Need anything else?

Contributors list

No Data

Spores

Scala Spores, safe mobile closures: SIP-21

Building Spores

The Spores project is built and tested using sbt. It has two modules:

spores-core
and
spores-pickling
. The
spores-core
module contains the core type definitions and the
spore
macro. The
spores-pickling
module integrates Spores with scala/pickling by providing picklers for Spores.

To build the core Spores module: ```

project spores-core compile ```

To run the test suite: ```

test ```

Get Spores

The

spores-core
and
spores-pickling
modules for Scala 2.11 are available on Maven Central and Sonatype. You can use Spores in your sbt project by simply adding the following dependency to your build file:
libraryDependencies += "org.scala-lang.modules" %% "spores-core" % "0.2.4"

To enable integration with Pickling, add the following dependency:

libraryDependencies += "org.scala-lang.modules" %% "spores-pickling" % "0.2.4"

Or you can just directly download the jar files (spores-core, spores-pickling).

Updates since the first draft (June 16th, 2013) of SIP-21

Many users expressed concern that spores would be both unusable with for- expression syntax, and would be incompatible (without a lot of boilerplate) with normal closures or higher-order functions which take normal functions as arguments.

Capture Syntax

To remedy the incompatibility with for-expressions, we propose a new

capture
syntax. Here is an exemplary use in the context of a hypothetical
DCollection
type:
def lookup(i: Int): DCollection[Int] = ...
val indices: DCollection[Int] = ...

for { i

Stable Paths

A stable path is an expression which only contains selections and identifiers (no applications, for example), and for which each selected entity is stable. In this context, stable means that the entity or object in question is introduced by object definitions or by value definitions of non-volatile types.

Adapted from the Scala Language specification (section 3.1), a path is defined to be one of the following:

  • C.this
    , where
    C
    references a class. The path
    this
    is taken as a shorthand for
    C.this
    where
    C
    is the name of the class directly enclosing the reference.
  • x
    where
    x
    is a package.
  • p.x
    where
    p
    is a path and
    x
    is a stable member of
    p
    . Stable members are packages or members introduced by object definitions or by value definitions of non-volatile types. (Section 3.6 of the SLS.)
  • C.super.x
    or
    C.super[M].x
    where
    C
    references a class and
    x
    references a stable member of the super class or designated parent class
    M
    of
    C
    . The prefix
    super
    is taken as a shorthand for
    C.super
    where
    C
    is the name of the class directly enclosing the reference.

A path refers to an object, that is, it ends with an identifier.

Uglies

  • Need to make it more convenient to create a nullary spore
  • Should objects be allowed in paths? The reason is that they are initialized lazily, so if we don't allow lazy vals, then allowing objects (which could end up being initialized only when the spore is applied) doesn't make a lot of sense.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.