scala.concurrent
object pilib

[source: `scala/concurrent/pilib.scala`]

`` `object` pilib
  `extends` AnyRef

  Library for using Pi-calculus concurrent primitives in Scala. As an example, the definition of a two-place buffer using the `pilib` library looks like:

        def Buffer[a](put: Chan[a], get: Chan[a]): unit = {
          def B0: unit = choice ( put * { x => B1(x) } );
          def B1(x: a): unit = choice ( get(x) * B0, put * { y => B2(x, y) } )
          def B2(x: a, y: a): unit = choice ( get(x) * B1(y) )
          B0
        }

See Also
  PiLib: A Hosted Language for Pi-Calculus Style Concurrency
Author
  Vincent Cremet, Martin Odersky
Version
  1.0

Value Summary
`val` | spawn : Spawn

Method Summary
`def` | choice [a](s : GP[a]*) : a Pi-calculus non-deterministic choice.

Methods inherited from AnyRef
getClass, hashCode, equals, clone, toString, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized

Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf

Class Summary
`class` | Chan [a]`extends` UChan `with` (a) => Product[a] Name on which one can emit, receive or that can be emitted or received during a communication.
`class` | GP [a](n : UChan, polarity : Boolean, v : Any, c : (Any) => a)`extends` AnyRef Typed guarded process.
`class` | Product [a](c : Chan[a], v : a)`extends` AnyRef
`abstract class` | Spawn `extends` AnyRef Run several processes in parallel using the following syntax: `spawn < p1 | ... | pn >`
`case class` | Sum (`val` gs : List[UGP])`extends` Product
`class` | UChan `extends` AnyRef Untyped channel.
`case class` | UGP (`val` n : UChan, `val` polarity : Boolean, `val` v : Any, `val` c : (Any) => Any)`extends` Product An untyped guarded process.

Value Details

`` `val` spawn : Spawn

Method Details

`` `def` choice[a](s : GP[a]*) : a

  Pi-calculus non-deterministic choice.

Parameters
  `s -` ...
Returns
  ...