diff options
Diffstat (limited to 'doc/reference/examples.verb.tex')
-rw-r--r-- | doc/reference/examples.verb.tex | 182 |
1 files changed, 91 insertions, 91 deletions
diff --git a/doc/reference/examples.verb.tex b/doc/reference/examples.verb.tex index 60036eb5ac..8aed1941c6 100644 --- a/doc/reference/examples.verb.tex +++ b/doc/reference/examples.verb.tex @@ -1329,7 +1329,7 @@ Scala does not have a built-in type of rational numbers, but it is easy to define one, using a class. Here's a possible implementation. \begin{verbatim} -class Rational(n: int, d: int) with { +class Rational(n: int, d: int) { private def gcd(x: int, y: int): int = { if (x == 0) y else if (x < 0) gcd(-x, y) @@ -1391,7 +1391,7 @@ If a class does not mention a superclass in its definition, the root class \verb@Object@ is implicitly assumed. For instance, class \verb@Rational@ could equivalently be defined as \begin{verbatim} -class Rational(n: int, d: int) extends Object with { +class Rational(n: int, d: int) extends Object { ... // as before } \end{verbatim} @@ -1411,7 +1411,7 @@ forms a string consisting of the object's class name and a number. It makes sense to redefine this method for objects that are rational numbers: \begin{verbatim} -class Rational(n: int, d: int) extends Object with { +class Rational(n: int, d: int) extends Object { ... // as before override def toString() = numer + "/" + denom; } @@ -1440,7 +1440,7 @@ Also unlike in Java, methods in Scala do not necessarily take a parameter list. An example is the \verb@square@ method below. This method is invoked by simply mentioning its name. \begin{verbatim} -class Rational(n: int, d: int) extends Object with { +class Rational(n: int, d: int) extends Object { ... // as before def square = Rational(numer*numer, denom*denom); } @@ -2839,7 +2839,7 @@ Classes in Scala can have type parameters. We demonstrate the use of type parameters with iterators as an example. An iterator is an object which traverses a sequence of values, using two abstract methods. \begin{verbatim} -abstract class Iterator[a] with { +abstract class Iterator[a] { def hasNext: boolean; def next: a; \end{verbatim} @@ -2920,7 +2920,7 @@ inferred to be \verb@int@). Method \verb@append@ constructs an iterator which resumes with the given iterator \verb@it@ after the current iterator has finished. \begin{verbatim} - def append(that: Iterator[a]): Iterator[a] = new Iterator[a] with { + def append(that: Iterator[a]): Iterator[a] = new Iterator[a] { def hasNext = outer.hasNext || that.hasNext; def next = if (outer.hasNext) outer.next else that.next; } @@ -2938,8 +2938,8 @@ constructed by \verb@append@, which is not what we want. Method \verb@filter@ constructs an iterator which returns all elements of the original iterator that satisfy a criterion \verb@p@. \begin{verbatim} - def filter(p: a => boolean) = new Iterator[a] with { - private class Cell[T](elem_: T) with { def elem = elem_; } + def filter(p: a => boolean) = new Iterator[a] { + private class Cell[T](elem_: T) { def elem = elem_; } private var head: Cell[a] = null; private var isAhead = false; def hasNext: boolean = @@ -2955,7 +2955,7 @@ of the original iterator that satisfy a criterion \verb@p@. Method \verb@map@ constructs an iterator which returns all elements of the original iterator transformed by a given function \verb@f@. \begin{verbatim} - def map[b](f: a => b) = new Iterator[b] with { + def map[b](f: a => b) = new Iterator[b] { def hasNext: boolean = outer.hasNext; def next: b = f(outer.next); } @@ -2985,7 +2985,7 @@ Finally, method \verb@zip@ takes another iterator and returns an iterator consisting of pairs of corresponding elements returned by the two iterators. \begin{verbatim} - def zip[b](that: Iterator[b]) = new Iterator[(a, b)] with { + def zip[b](that: Iterator[b]) = new Iterator[(a, b)] { def hasNext = outer.hasNext && that.hasNext; def next = (outer.next, that.next); } @@ -2996,7 +2996,7 @@ abstract methods \verb@next@ and \verb@hasNext@ in class \verb@Iterator@. The simplest iterator is \verb@EmptyIterator@ which always returns an empty sequence: \begin{verbatim} -class EmptyIterator[a] extends Iterator[a] with { +class EmptyIterator[a] extends Iterator[a] { def hasNext = false; def next: a = error("next on empty iterator"); } @@ -3007,7 +3007,7 @@ have also been written as a class, like \verb@EmptyIterator@. The difference between the two formulation is that classes also define new types, whereas functions do not. \begin{verbatim} -def arrayIterator[a](xs: Array[a]) = new Iterator[a] with { +def arrayIterator[a](xs: Array[a]) = new Iterator[a] { private var i = 0; def hasNext: boolean = i < xs.length; @@ -3018,7 +3018,7 @@ def arrayIterator[a](xs: Array[a]) = new Iterator[a] with { \end{verbatim} Another iterator enumerates an integer interval: \begin{verbatim} -def range(lo: int, hi: int) = new Iterator[int] with { +def range(lo: int, hi: int) = new Iterator[int] { private var i = lo; def hasNext: boolean = i <= hi; @@ -3040,7 +3040,7 @@ iterator returns successive integers from some start value\footnote{Due to the finite representation of type \prog{int}, numbers will wrap around at $2^31$.}. \begin{verbatim} -def from(start: int) = new Iterator[int] with { +def from(start: int) = new Iterator[int] { private var last = start - 1; def hasNext = true; def next = { last = last + 1; last } @@ -3096,7 +3096,7 @@ Classes can also omit some of the definitions of their members. As an example, consider the following class \verb@Ord@ which provides the comparison operators \verb@<, >, <=, >=@. %\begin{verbatim} -%abstract class Ord with { +%abstract class Ord { % abstract def <(that: this); % def <=(that: this) = this < that || this == that; % def >(that: this) = that < this; @@ -3104,7 +3104,7 @@ comparison operators \verb@<, >, <=, >=@. %} %\end{verbatim} \begin{verbatim} -abstract class Ord with { +abstract class Ord { def <(that: this): boolean; def <=(that: this) = this < that || this == that; def >(that: this) = that < this; @@ -3131,7 +3131,7 @@ We can now define a class of \verb@Rational@ numbers that support comparison operators. \begin{verbatim} final class OrderedRational(n: int, d: int) - extends Rational(n, d) with Ord with { + extends Rational(n, d) with Ord { override def ==(that: OrderedRational) = numer == that.numer && denom == that.denom; def <(that: OrderedRational): boolean = @@ -3189,7 +3189,7 @@ Classes in Scala can have type parameters. We demonstrate the use of type parameters with iterators as an example. An iterator is an object which traverses a sequence of values, using two abstract methods. \begin{verbatim} -abstract class Iterator[a] with { +abstract class Iterator[a] { def hasNext: boolean; def next: a; \end{verbatim} @@ -3212,7 +3212,7 @@ returning \verb@unit@ to each element returned by the iterator: Method \verb@append@ constructs an iterator which resumes with the given iterator \verb@it@ after the current iterator has finished. \begin{verbatim} - def append(that: Iterator[a]): Iterator[a] = new Iterator[a] with { + def append(that: Iterator[a]): Iterator[a] = new Iterator[a] { def hasNext = outer.hasNext || that.hasNext; def next = if (outer.hasNext) outer.next else that.next; } @@ -3230,8 +3230,8 @@ constructed by \verb@append@, which is not what we want. Method \verb@filter@ constructs an iterator which returns all elements of the original iterator that satisfy a criterion \verb@p@. \begin{verbatim} - def filter(p: a => boolean) = new Iterator[a] with { - private class Cell[T](elem_: T) with { def elem = elem_; } + def filter(p: a => boolean) = new Iterator[a] { + private class Cell[T](elem_: T) { def elem = elem_; } private var head: Cell[a] = null; private var isAhead = false; def hasNext: boolean = @@ -3247,7 +3247,7 @@ of the original iterator that satisfy a criterion \verb@p@. Method \verb@map@ constructs an iterator which returns all elements of the original iterator transformed by a given function \verb@f@. \begin{verbatim} - def map[b](f: a => b) = new Iterator[b] with { + def map[b](f: a => b) = new Iterator[b] { def hasNext: boolean = outer.hasNext; def next: b = f(outer.next); } @@ -3277,7 +3277,7 @@ Finally, method \verb@zip@ takes another iterator and returns an iterator consisting of pairs of corresponding elements returned by the two iterators. \begin{verbatim} - def zip[b](that: Iterator[b]) = new Iterator[(a, b)] with { + def zip[b](that: Iterator[b]) = new Iterator[(a, b)] { def hasNext = outer.hasNext && that.hasNext; def next = (outer.next, that.next); } @@ -3288,7 +3288,7 @@ abstract methods \verb@next@ and \verb@hasNext@ in class \verb@Iterator@. The simplest iterator is \verb@EmptyIterator@ which always returns an empty sequence: \begin{verbatim} -class EmptyIterator[a] extends Iterator[a] with { +class EmptyIterator[a] extends Iterator[a] { def hasNext = false; def next: a = error("next on empty iterator"); } @@ -3299,7 +3299,7 @@ have also been written as a class, like \verb@EmptyIterator@. The difference between the two formulation is that classes also define new types, whereas functions do not. \begin{verbatim} -def arrayIterator[a](xs: Array[a]) = new Iterator[a] with { +def arrayIterator[a](xs: Array[a]) = new Iterator[a] { private var i = 0; def hasNext: boolean = i < xs.length; @@ -3310,7 +3310,7 @@ def arrayIterator[a](xs: Array[a]) = new Iterator[a] with { \end{verbatim} Another iterator enumerates an integer interval: \begin{verbatim} -def range(lo: int, hi: int) = new Iterator[int] with { +def range(lo: int, hi: int) = new Iterator[int] { private var i = lo; def hasNext: boolean = i <= hi; @@ -3332,7 +3332,7 @@ iterator returns successive integers from some start value\footnote{Due to the finite representation of type \prog{int}, numbers will wrap around at $2^31$.}. \begin{verbatim} -def from(start: int) = new Iterator[int] with { +def from(start: int) = new Iterator[int] { private var last = start - 1; def hasNext = true; def next = { last = last + 1; last } @@ -3444,22 +3444,22 @@ database query languages. For instance, say we are given a book database \verb@books@, represented as a list of books, where \verb@Book@ is defined as follows. \begin{verbatim} -abstract class Book with { +abstract class Book { val title: String; val authors: List[String] } \end{verbatim} \begin{verbatim} val books: List[Book] = [ - new Book with { + new Book { val title = "Structure and Interpretation of Computer Programs"; val authors = ["Abelson, Harald", "Sussman, Gerald J."]; }, - new Book with { + new Book { val title = "Principles of Compiler Design"; val authors = ["Aho, Alfred", "Ullman, Jeffrey"]; }, - new Book with { + new Book { val title = "Programming in Modula-2"; val authors = ["Wirth, Niklaus"]; } @@ -3603,7 +3603,7 @@ Note that the class \verb@Tree@ is not followed by an extends clause or a body. This defines \verb@Tree@ to be an empty subclass of \verb@Object@, as if we had written \begin{verbatim} -class Tree extends Object with {} +class Tree extends Object {} \end{verbatim} Note also that the two subclasses of \verb@Tree@ have a \verb@case@ modifier. That modifier has two effects. First, it lets us construct @@ -3671,7 +3671,7 @@ find(xs, x) match { \comment{ -class MaxCounter with { +class MaxCounter { var maxVal: Option[int] = None; def set(x: int) = maxVal match { case None => maxVal = Some(x) @@ -3684,7 +3684,7 @@ class MaxCounter with { \begin{verbatim} class Stream[a] = List[a] -module Stream with { +module Stream { def concat(xss: Stream[Stream[a]]): Stream[a] = { let result: Stream[a] = xss match { case [] => [] @@ -3704,8 +3704,8 @@ three different styles: algebraic, object-oriented, and imperative. In each case, a search tree package is seen as an implementation of a class {\em MapStruct}. \begin{verbatim} -abstract class MapStruct[kt, vt] with { - abstract type Map extends kt => vt with { +abstract class MapStruct[kt, vt] { + abstract type Map extends kt => vt { def apply(key: kt): vt; def extend(key: kt, value: vt): Map; def remove(key: kt): Map; @@ -3734,12 +3734,12 @@ representation as the receiver object. \begin{figure}[t] \begin{verbatim} -class AlgBinTree[kt extends Ord, vt] extends MapStruct[kt, vt] with { +class AlgBinTree[kt extends Ord, vt] extends MapStruct[kt, vt] { private case Empty extends Map, Node(key: kt, value: vt, l: Map, r: Map) extends Map - final class Map extends kt => vt with { + final class Map extends kt => vt { def apply(key: kt): vt = this match { case Empty => null case Node(k, v, l, r) => @@ -3809,22 +3809,22 @@ are constructed lazily. \begin{figure}[thb] \begin{verbatim} -class OOBinTree[kt extends Ord, vt] extends MapStruct[kt, vt] with { - abstract class Map extends kt => vt with { +class OOBinTree[kt extends Ord, vt] extends MapStruct[kt, vt] { + abstract class Map extends kt => vt { def apply(key: kt): v def extend(key: kt, value: vt): Map def remove(key: kt): Map def domain: Stream[kt] def range: Stream[vt] } - module empty extends Map with { + module empty extends Map { def apply(key: kt) = null def extend(key: kt, value: vt) = Node(key, value, empty, empty) def remove(key: kt) = empty def domain = [] def range = [] } - private class Node(k: kt, v: vt, l: Map, r: Map) extends Map with { + private class Node(k: kt, v: vt, l: Map, r: Map) extends Map { def apply(key: kt): vt = if (key < k) l.apply(key) else if (key > k) r.apply(key) @@ -3877,8 +3877,8 @@ modified. \begin{figure} \begin{verbatim} -class MutBinTree[kt extends Ord, vt] extends MapStruct[kt, vt] with { - class Map(key: kt, value: vt) extends kt => vt with { +class MutBinTree[kt extends Ord, vt] extends MapStruct[kt, vt] { + class Map(key: kt, value: vt) extends kt => vt { val k = key var v = value var l = empty, r = empty @@ -4029,7 +4029,7 @@ by a straightforward rewrite of the grammar, replacing \verb@::=@ with Applying this process to the grammar of arithmetic expressions yields: \begin{verbatim} -module ExprParser with { +module ExprParser { import Parse; def letter \= = \= chrWith(c => c.isLetter); @@ -4050,11 +4050,11 @@ is which underlying representation type to use for a parser. We treat parsers here as functions that take a list of characters as input parameter and that yield a parse result. \begin{verbatim} -module Parse with { +module Parse { type Result = Option[List[char]]; - abstract class Parser extends Function1[List[char],Result] with { + abstract class Parser extends Function1[List[char],Result] { \end{verbatim} \comment{ The \verb@Option@ type is predefined as follows. @@ -4079,14 +4079,14 @@ method, as well as methods \verb@&&&@ and \verb@|||@. abstract def apply(in: List[char]): Result; \end{verbatim} \begin{verbatim} - def &&& (def p: Parser) = new Parser with { + def &&& (def p: Parser) = new Parser { def apply(in: List[char]) = outer.apply(in) match { case Some(in1) => p(in1) case n => n } } - def ||| (def p: Parser) = new Parser with { + def ||| (def p: Parser) = new Parser { def apply(in: List[char]) = outer.apply(in) match { case None => p(in) case s => s @@ -4098,11 +4098,11 @@ The implementations of the primitive parsers \verb@empty@, \verb@fail@, \verb@chrWith@ and \verb@chr@ are as follows. \begin{verbatim} - def empty = new Parser with { def apply(in: List[char]) = Some(in) } + def empty = new Parser { def apply(in: List[char]) = Some(in) } - def fail = new Parser with { def apply(in: List[char]) = None[List[char]] } + def fail = new Parser { def apply(in: List[char]) = None[List[char]] } - def chrWith(p: char => boolean) = new Parser with { + def chrWith(p: char => boolean) = new Parser { def apply(in: List[char]) = in match { case [] => None[List[char]] case (c :: in1) => if (p(c)) Some(in1) else None[List[char]] @@ -4233,7 +4233,7 @@ We now present the parser combinators that support the new scheme. Parsers that succeed now return a parse result besides the un-consumed input. \begin{verbatim} -module Parse with { +module Parse { type Result[a] = Option[(a, List[char])] \end{verbatim} @@ -4245,32 +4245,32 @@ Chapter~\ref{sec:for-notation}. Here is the complete definition of the new \verb@Parser@ class. \begin{verbatim} - abstract class Parser[a] extends Function1[List[char],Result[a]] with { + abstract class Parser[a] extends Function1[List[char],Result[a]] { def apply(in: List[char]): Result[a]; - def filter(p: a => boolean) = new Parser[a] with { + def filter(p: a => boolean) = new Parser[a] { def apply(in: List[char]): Result[a] = outer.apply(in) match { case Some((x, in1)) => if (p(x)) Some((x, in1)) else None case None => None } } - def map[b](f: a => b) = new Parser[b] with { + def map[b](f: a => b) = new Parser[b] { def apply(in: List[char]): Result[b] = outer.apply(in) match { case Some((x, in1)) => Some((f(x), in1)) case None => None } } - def flatMap[b](f: a => Parser[b]) = new Parser[b] with { + def flatMap[b](f: a => Parser[b]) = new Parser[b] { def apply(in: List[char]): Result[b] = outer.apply(in) match { case Some((x, in1)) => f(x)(in1) case None => None } } - def ||| (def p: Parser[a]) = new Parser[a] with { + def ||| (def p: Parser[a]) = new Parser[a] { def apply(in: List[char]): Result[a] = outer.apply(in) match { case None => p(in) case s => s @@ -4296,9 +4296,9 @@ the current parser and then continues with the resulting parser. The % Here is the code for fail, chrWith and chr % %\begin{verbatim} -% def fail[a] = new Parser[a] with { def apply(in: List[char]) = None[(a,List[char])] } +% def fail[a] = new Parser[a] { def apply(in: List[char]) = None[(a,List[char])] } % -% def chrWith(p: char => boolean) = new Parser[char] with { +% def chrWith(p: char => boolean) = new Parser[char] { % def apply(in: List[char]) = in match { % case [] => None[(char,List[char])] % case (c :: in1) => if (p(c)) Some((c,in1)) else None[(char,List[char])] @@ -4310,7 +4310,7 @@ the current parser and then continues with the resulting parser. The The primitive parser \verb@succeed@ replaces \verb@empty@. It consumes no input and returns its parameter as result. \begin{verbatim} - def succeed[a](x: a) = new Parser[a] with { + def succeed[a](x: a) = new Parser[a] { def apply(in: List[char]) = Some((x, in)) } \end{verbatim} @@ -4356,7 +4356,7 @@ program. The next data type describes the form of types that are computed by the inference system. \begin{verbatim} -module Types with { +module Types { abstract final class Type; case class Tyvar(a: String) extends Type; case class Arrow(t1: Type, t2: Type) extends Type; @@ -4398,7 +4398,7 @@ Even though there is only one possible way to construct a type scheme, a \verb@case class@ representation was chosen since it offers a convenient way to decompose a type scheme into its parts using pattern matching. \begin{verbatim} -case class TypeScheme(ls: List[String], t: Type) with { +case class TypeScheme(ls: List[String], t: Type) { def newInstance: Type = { val instSubst = ((EmptySubst: Subst) :_foldl ls) { s, a => s.extend(Tyvar(a), newTyvar) } @@ -4417,18 +4417,18 @@ type variables unchanged. The meaning of a substitution is extended point-wise to a mapping from types to types. \begin{verbatim} -abstract class Subst extends Function1[Type,Type] with { +abstract class Subst extends Function1[Type,Type] { def lookup(x: Tyvar): Type; def apply(t: Type): Type = t match { case Tyvar(a) => val u = lookup(Tyvar(a)); if (t == u) t else apply(u); case Arrow(t1, t2) => Arrow(apply(t1), apply(t2)) case Tycon(k, ts) => Tycon(k, ts map apply) } - def extend(x: Tyvar, t: Type) = new Subst with { + def extend(x: Tyvar, t: Type) = new Subst { def lookup(y: Tyvar): Type = if (x == y) t else outer.lookup(y); } } -case class EmptySubst extends Subst with { def lookup(t: Tyvar): Type = t } +case class EmptySubst extends Subst { def lookup(t: Tyvar): Type = t } \end{verbatim} We represent substitutions as functions, of type \verb@Type => Type@. To be an instance of this type, a @@ -4446,7 +4446,7 @@ membership tests as well as \verb@union@ and \verb@diff@ for set union and difference. Alternatively, one could have used a more efficient implementation of sets in some standard library. \begin{verbatim} -class ListSet[a](xs: List[a]) with { +class ListSet[a](xs: List[a]) { val elems: List[a] = xs; def contains(y: a): boolean = xs match { @@ -4475,7 +4475,7 @@ computes a type for a given term in a given environment. Environments associate variable names with type schemes. They are represented by a type alias \verb@Env@ in module \verb@TypeChecker@: \begin{verbatim} -module TypeChecker with { +module TypeChecker { /** Type environments are lists of bindings that associate a * name with a type scheme. @@ -4612,7 +4612,7 @@ bindings for booleans, numbers and lists together with some primitive operations over these types. It also defines a fixed point operator \verb@fix@, which can be used to represent recursion. \begin{verbatim} -module Predefined with { +module Predefined { val booleanType = Tycon("Boolean", []); val intType = Tycon("Int", []); def listType(t: Type) = Tycon("List", [t]); @@ -4666,7 +4666,7 @@ how they can be implemented in Scala. The {\em monitor} provides the basic means for mutual exclusion of processes in Scala. It is defined as follows. \begin{verbatim} -class Monitor with { +class Monitor { def synchronized [a] (def e: a): a; } \end{verbatim} @@ -4683,7 +4683,7 @@ other thread. Calls to \verb@send@ with no threads waiting for the signal are ignored. Here is the specification of the \verb@Signal@ class. \begin{verbatim} -class Signal with { +class Signal { def wait: unit; def wait(msec: long): unit; def notify: unit; @@ -4700,7 +4700,7 @@ Scala which are implemented in terms of the underlying runtime system. As an example of how monitors and signals are used, here is is an implementation of a bounded buffer class. \begin{verbatim} -class BoundedBuffer[a](N: int) extends Monitor with { +class BoundedBuffer[a](N: int) extends Monitor { var in = 0, out = 0, n = 0; val elems = new Array[a](N); val nonEmpty = new Signal; @@ -4733,7 +4733,7 @@ The \verb@fork@ method spawns a new thread which executes the expression given in the parameter. It can be defined as follows. \begin{verbatim} def fork(def e: unit) = { - val p = new Thread with { def run = e; } + val p = new Thread { def run = e; } p.run } \end{verbatim} @@ -4749,7 +4749,7 @@ blocks until the variable has been defined. Logic variables can be implemented as follows. \begin{verbatim} -class LVar[a] extends Monitor with { +class LVar[a] extends Monitor { private val defined = new Signal private var isDefined: boolean = false private var v: a @@ -4773,7 +4773,7 @@ resets the variable to undefined state. Synchronized variables can be implemented as follows. \begin{verbatim} -class SyncVar[a] extends Monitor with { +class SyncVar[a] extends Monitor { private val defined = new Signal; private var isDefined: boolean = false; private var value: a; @@ -4878,7 +4878,7 @@ A common mechanism for process synchronization is a {\em lock} (or: \prog{release}. Here's the implementation of a lock in Scala: \begin{verbatim} -class Lock extends Monitor with Signal with { +class Lock extends Monitor with Signal { var available = true; def acquire = { if (!available) wait; @@ -4908,7 +4908,7 @@ The following implementation of a readers/writers lock is based on the {\em message space} concept (see Section~\ref{sec:messagespace}). \begin{verbatim} -class ReadersWriters with { +class ReadersWriters { val m = new MessageSpace; private case class Writers(n: int), Readers(n: int); Writers(0); Readers(0); @@ -4939,7 +4939,7 @@ A fundamental way of interprocess communication is the asynchronous channel. Its implementation makes use the following class for linked lists: \begin{verbatim} -class LinkedList[a](x: a) with { +class LinkedList[a](x: a) { val elem: a = x; var next: LinkedList[a] = null; } @@ -4953,7 +4953,7 @@ The channel class uses a linked list to store data that has been sent but not read yet. In the opposite direction, a signal \verb@moreData@ is used to wake up reader threads that wait for data. \begin{verbatim} -class Channel[a] with { +class Channel[a] { private val written = new LinkedList[a](null); private var lastWritten = written; private val moreData = new Signal; @@ -4979,7 +4979,7 @@ a message blocks until that message has been received. Synchronous channels only need a single variable to store messages in transit, but three signals are used to coordinate reader and writer processes. \begin{verbatim} -class SyncChannel[a] with { +class SyncChannel[a] { val data = new SyncVar[a]; def write(x: a): unit = synchronized { @@ -5014,7 +5014,7 @@ processor. \begin{verbatim} class ComputeServer(n: int) { - private abstract class Job with { + private abstract class Job { abstract type t; def task: t; def return(x: t): unit; @@ -5033,7 +5033,7 @@ class ComputeServer(n: int) { def future[a](def p: a): () => a = { val reply = new SyncVar[a]; openJobs.write( - new Job with { + new Job { type t = a; def task = p; def return(x: a) = reply.set(x); @@ -5088,7 +5088,7 @@ case class TIMEOUT; \end{verbatim} Message spaces implement the following signature. \begin{verbatim} -class MessageSpace with { +class MessageSpace { def send(msg: Any): unit; def receive[a](f: PartialFunction[Any, a]): a; def receiveWithin[a](msec: long)(f: PartialFunction[Any, a]): a; @@ -5112,7 +5112,7 @@ time. As a simple example of how message spaces are used, consider a one-place buffer: \begin{verbatim} -class OnePlaceBuffer with { +class OnePlaceBuffer { private val m = new MessageSpace; \=// An internal message space private case class Empty, Full(x: int); \>// Types of messages we deal with @@ -5127,9 +5127,9 @@ class OnePlaceBuffer with { \end{verbatim} Here's how the message space class can be implemented: \begin{verbatim} -class MessageSpace with { +class MessageSpace { - private abstract class Receiver extends Signal with { + private abstract class Receiver extends Signal { def isDefined(msg: Any): boolean; var msg = null; } @@ -5177,7 +5177,7 @@ Otherwise, the message is appended to the linked list of sent messages. s.next = s1.next; s1.elem } else { val r = new LinkedList( - new Receiver with { + new Receiver { def isDefined(msg: Any) = f.isDefined(msg); }); lastReceiver.next = r; lastReceiver = r; @@ -5213,7 +5213,7 @@ with the special \verb@TIMEOUT@ message. The implementation of s.next = s1.next; s1.elem } else { val r = new LinkedList( - new Receiver with { + new Receiver { def isDefined(msg: Any) = f.isDefined(msg); } ) @@ -5268,7 +5268,7 @@ case class \begin{verbatim} class Auction(seller: Process, minBid: int, closing: Date) - extends Process with { + extends Process { val timeToShutdown = 36000000 // msec val delta = 10 // bid increment @@ -5336,7 +5336,7 @@ class Auction(seller: Process, minBid: int, closing: Date) \end{verbatim} \begin{verbatim} class Bidder (auction: Process, minBid: int, maxBid: int) - extends Process with { + extends Process { val MaxTries = 3 val Unknown = -1 @@ -5451,7 +5451,7 @@ def sort(a:Array[String]): Array[String] = { sort1(0, a.length - 1) } -class Array[a] with { +class Array[a] { def copy(to: Array[a], src: int, dst: int, len: int): unit val length: int |