Merge pull request #23 from CodaFi/beta-sixx

Update to beta 6

Author: CodaFi

Carthage/Checkouts/SwiftCheck

@@ -8,23 +8,23 @@
 
 public struct Future<A> {
 	let threadID : MVar<Optional<ThreadID>>
-	let cOptional : IVar<Optional<A>>
+	let completionLock : IVar<Optional<A>>
 	let finalizers : MVar<[Optional<A> -> ()]>
 
 	private init(_ threadID : MVar<Optional<ThreadID>>, _ cOptional : IVar<Optional<A>>, _ finalizers : MVar<[Optional<A> -> ()]>) {
 		self.threadID = threadID
-		self.cOptional = cOptional
+		self.completionLock = cOptional
 		self.finalizers = finalizers
 	}
 
 	public func read() -> Optional<A> {
-		return self.cOptional.read()
+		return self.completionLock.read()
 	}
 
 	public func then(finalize : Optional<A> -> ()) -> Future<A> {
 		do {
 			let ma : Optional<Optional<A>> = try self.finalizers.modify { sTodo in
-				let res = self.cOptional.tryRead()
+				let res = self.completionLock.tryRead()
 				if res == nil {
 					return (sTodo + [finalize], res)
 				}
@@ -44,7 +44,7 @@ public struct Future<A> {
 	}
 
 	private func complete(r : Optional<A>) -> Optional<A> {
-		return self.cOptional.tryPut(r) ? r : self.cOptional.read()
+		return self.completionLock.tryPut(r) ? r : self.completionLock.read()
 	}
 
 	private func runFinalizerWithOptional<A>(val : Optional<A>) -> (Optional<A> -> ()) -> ThreadID {
@@ -60,10 +60,10 @@ public func forkFutures<A>(ios : [() -> A]) -> Chan<Optional<A>> {
 
 public func forkFuture<A>(io : () throws -> A) -> Future<A> {
 	let msTid = MVar<ThreadID?>()
-	let Optional : IVar<A?> = IVar()
+	let lock : IVar<A?> = IVar()
 	let msTodo : MVar<[A? -> ()]> = MVar(initial: [])
 
-	let p = Future(msTid, Optional, msTodo)
+	let p = Future(msTid, lock, msTodo)
 	let act : () -> () = {
 		p.threadID.put(.Some(myTheadID()))
 		_ = p.complete({
@@ -80,7 +80,9 @@ public func forkFuture<A>(io : () throws -> A) -> Future<A> {
 		p.threadID.modify_({ _ in .None })
 		let val = p.complete(paranoid)
 		let sTodo = p.finalizers.swap([])
-		sTodo.forEach { _ in p.runFinalizerWithOptional(val) }
+		sTodo.forEach { _ in
+			let _ = p.runFinalizerWithOptional(val)
+		}
 	}
 
 	_ = forkIO {

Concurrent/Future.swift

@@ -93,7 +93,7 @@ public struct SVar<A> {
 /// have had its value swapped out from under you.  It is better to `read()` the values yourself
 /// if you need a stricter equality.
 public func ==<A : Equatable>(lhs : SVar<A>, rhs : SVar<A>) -> Bool {
-	if lhs.isEmpty && !rhs.isEmpty {
+	if lhs.isEmpty && rhs.isEmpty {
 		return true
 	}
 	if lhs.isEmpty != rhs.isEmpty {

Concurrent/SVar.swift

@@ -11,25 +11,20 @@ import XCTest
 
 typealias Name = String
 
-internal class Box<T> {
-    let value : T
-    internal init(_ x : T) { self.value = x }
-}
-
 /// An encoding of the Pi Calculus, a process calculus of names and channels with equal expressive
 /// power to the Lambda Calculus.
-enum π {
+indirect enum π {
 	/// Run the left and right computations simultaneously
-	case Simultaneously(Box<π>, Box<π>)
+	case Simultaneously(π, π)
 	/// Repeatedly spawn and execute copies of this computation forever.
-	case Rep(Box<π>)
+	case Rep(π)
 	/// Create a new channel with a given name, then run the next computation.
-	case New(Name, Box<π>)
+	case New(Name, π)
 	/// Send a value over the channel with a given name, then run the next computation.
-	case Send(Name, Name, Box<π>)
-	/// Recieve a value on the channel with a given name, bind the result to the name, then run
+	case Send(Name, Name, π)
+	/// Receive a value on the channel with a given name, bind the result to the name, then run
 	/// the next computation.
-	case Recieve(Name, Name, Box<π>)
+	case Receive(Name, Name, π)
 	/// Terminate the process.
 	case Terminate
 }
@@ -45,19 +40,12 @@ struct Mu {
 
 typealias Environment = Dictionary<Name, Mu>
 
-func forever<A>(@autoclosure(escaping) io :  () -> A) -> (() -> A) {
-	return { 
-		io() 
-		return forever(io)() 
-	}
-}
-
 func runπ(var env : Environment, _ pi : π) -> () {
 	switch pi {
 		case .Simultaneously(let ba, let bb):
 			let f = { x in forkIO(runπ(env, x)) }
-			f(ba.value)
-			f(bb.value)
+			f(ba)
+			f(bb)
 		case .Rep(let bp):
 			return runπ(env, π.Rep(bp))
 		case .Terminate:
@@ -66,16 +54,16 @@ func runπ(var env : Environment, _ pi : π) -> () {
 			let c : Chan<Mu> = Chan()
 			let mu = Mu(c)
 			env[bind] = mu
-			return runπ(env, bp.value)
+			return runπ(env, bp)
 		case .Send(let msg, let dest, let bp):
 			let w = env[dest]
 			w?.c.write(env[msg]!)
-			return runπ(env, bp.value)
-		case .Recieve(let src, let bind, let bp):
+			return runπ(env, bp)
+		case .Receive(let src, let bind, let bp):
 			let w = env[src]
 			let recv = w?.c.read()
 			env[bind] = recv
-			forkIO(runπ(env, bp.value))
+			forkIO(runπ(env, bp))
 	}
 }
 
@@ -91,32 +79,37 @@ infix operator !|! {
 }
 
 func !|! (l : π, r : π) -> π {
-	return .Simultaneously(Box(l), Box(r))
+	return .Simultaneously(l, r)
 }
 
 func `repeat`(p : π) -> π {
-	return .Rep(Box(p))
+	return .Rep(p)
 }
 
 func terminate() -> π {
 	return .Terminate
 }
 
 func newChannel(n : Name, then : π) -> π {
-	return .New(n, Box(then))
+	return .New(n, then)
 }
 
 func send(v : Name, on : Name, then : π) -> π {
-	return .Send(v, on, Box(then))
+	return .Send(v, on, then)
 }
 
-func recieve(on : Name, v : Name, then : π) -> π {
-	return .Recieve(v, on, Box(then))
+func receive(on : Name, v : Name, then : π) -> π {
+	return .Receive(v, on, then)
 }
 
 class PiCalculusSpec : XCTestCase {
 	func testPi() {
-		let pi = newChannel("x", then: send("x", on: "z", then: terminate()) !|! recieve("x", v: "y", then: send("y", on: "x", then: recieve("x", v: "y", then: terminate()))) !|! send("z", on: "v", then: recieve("v", v: "v", then: terminate())))
+		let pi = newChannel("x", then:
+					send("x", on: "z", then: terminate())
+					!|!
+					receive("x", v: "y", then: send("y", on: "x", then: receive("x", v: "y", then: terminate())))
+					!|!
+					send("z", on: "v", then: receive("v", v: "v", then: terminate())))
 		runCompute(pi)
 	}
 }