Merge pull request #46 from CodaFi/pchan-tchan

Introduce laziness into TChan and ditch custom list

Author: CodaFi

.travis.yml

@@ -5,7 +5,7 @@ matrix:
   include:
     - os: osx
       language: objective-c
-      osx_image: xcode8
+      osx_image: xcode8.3
       before_install:
         - git submodule update --init --recursive
       script:
@@ -14,7 +14,7 @@ matrix:
         - carthage build --no-skip-current
     - os: osx
       language: objective-c
-      osx_image: xcode8
+      osx_image: xcode8.3
       before_install:
         - git submodule update --init --recursive
       script:
@@ -37,9 +37,9 @@ matrix:
       before_install:
         - git submodule update --init --recursive
         - wget -q -O - https://swift.org/keys/all-keys.asc | gpg --import -
-        - wget https://swift.org/builds/swift-3.0-release/ubuntu1404/swift-3.0-RELEASE/swift-3.0-RELEASE-ubuntu14.04.tar.gz
-        - tar xzf swift-3.0-RELEASE-ubuntu14.04.tar.gz
-        - export PATH=${PWD}/swift-3.0-RELEASE-ubuntu14.04/usr/bin:"${PATH}" 
+        - wget https://swift.org/builds/swift-3.1-release/ubuntu1404/swift-3.1-RELEASE/swift-3.1-RELEASE-ubuntu14.04.tar.gz
+        - tar xzf swift-3.1-RELEASE-ubuntu14.04.tar.gz
+        - export PATH=${PWD}/swift-3.1-RELEASE-ubuntu14.04/usr/bin:"${PATH}" 
       script:
         - swift build
 notifications:

Cartfile.resolved

@@ -1 +1 @@
-github "typelift/SwiftCheck" "v0.7.0"
+github "typelift/SwiftCheck" "0.8.0"

Carthage/Checkouts/SwiftCheck

@@ -6,26 +6,21 @@
 //  Copyright © 2015-2016 TypeLift. All rights reserved.
 //
 
-private indirect enum TList<A> {
-	case tNil
-	case tCons(A, TVar<TList<A>>)
-}
-
 /// Transactional Channels are unbounded FIFO streams of values with a read and
 /// write terminals comprised of `TVar`s.
 public struct TChan<A> {
-	private let readHead : TVar<TVar<TList<A>>>
-	private let writeHead : TVar<TVar<TList<A>>>
+	private let readHead : TVar<() -> TVar<[A]>>
+	private let writeHead : TVar<TVar<[A]>>
 
-	private init(_ readHead : TVar<TVar<TList<A>>>, _ writeHead : TVar<TVar<TList<A>>>) {
+	private init(_ readHead : TVar<() -> TVar<[A]>>, _ writeHead : TVar<TVar<[A]>>) {
 		self.readHead = readHead
 		self.writeHead = writeHead
 	}
 
 	/// Creates and returns a new empty channel.
 	public init() {
-		let hole : TVar<TList<A>> = TVar(TList.tNil)
-		let read = TVar(hole)
+		let hole : TVar<[A]> = TVar([])
+    let read = TVar({ hole })
 		let write = TVar(hole)
 		self = TChan(read, write)
 	}
@@ -34,16 +29,16 @@ public struct TChan<A> {
 	///
 	/// To read from a broadcast transactional channel, `duplicate()` it first.
 	public init(forBroadcast: ()) {
-		let hole : TVar<TList<A>> = TVar(TList.tNil)
-		let read : TVar<TVar<TList<A>>> = TVar(undefined())
+		let hole : TVar<[A]> = TVar([])
+    let read : TVar<() -> TVar<[A]>> = TVar({ undefined("reading from a TChan created by TChan.init(forBroadcast:); use duplicate() first") })
 		let write = TVar(hole)
 		self = TChan(read, write)
 	}
 
 	/// Uses an STM transaction to atomically create and return a new empty channel.
 	public func newTChan() -> STM<TChan<A>> {
-		let hole : TVar<TList<A>> = TVar(TList.tNil)
-		let read = TVar(hole)
+		let hole : TVar<[A]> = TVar([])
+    let read = TVar({ hole })
 		let write = TVar(hole)
 		return STM<TChan<A>>.pure(TChan(read, write))
 	}
@@ -52,29 +47,29 @@ public struct TChan<A> {
 	///
 	/// To read from a broadcast transactional channel, `duplicate()` it first.
 	public func newBroadcastTChan() -> STM<TChan<A>> {
-		let hole : TVar<TList<A>> = TVar(TList.tNil)
-		let read : TVar<TVar<TList<A>>> = TVar(undefined())
+		let hole : TVar<[A]> = TVar([])
+    let read : TVar<() -> TVar<[A]>> = TVar({ undefined("reading from a TChan created by newBroadcastTChan(); use duplicate() first") })
 		let write = TVar(hole)
 		return STM<TChan<A>>.pure(TChan(read, write))
 	}
 
 	/// Uses an STM transaction to atomically write a value to a channel.
 	public func write(_ val : A) -> STM<()> {
 		return self.writeHead.read().flatMap { l in
-			let nl : TVar<TList<A>> = TVar(TList.tNil)
-			return l.write(TList.tCons(val, nl)).then(self.writeHead.write(nl))
+			let nl : TVar<[A]> = TVar([])
+			return l.write([val]).then(self.writeHead.write(nl))
 		}
 	}
 
 	/// Uses an STM transaction to atomically read a value from the channel.
 	public func read() -> STM<A> {
 		return self.readHead.read().flatMap { hd in
-			return hd.read().flatMap { lst in
-				switch lst {
-				case .tNil:
+			return hd().read().flatMap { lst in
+				switch lst.match {
+				case .Nil:
 					return STM.retry()
-				case .tCons(let x, let xs):
-					return self.readHead.write(xs).then(STM<A>.pure(x))
+				case .Cons(let x, let xs):
+          return self.readHead.write({ TVar(xs) }).then(STM<A>.pure(x))
 				}
 			}
 		}
@@ -84,12 +79,12 @@ public struct TChan<A> {
 	/// without retrying on failure.
 	public func tryRead() -> STM<Optional<A>> {
 		return self.readHead.read().flatMap { hd in
-			return hd.read().flatMap { lst in
-				switch lst {
-				case .tNil:
+			return hd().read().flatMap { lst in
+				switch lst.match {
+				case .Nil:
 					return STM<Optional<A>>.pure(nil)
-				case .tCons(let x, let xs):
-					return self.readHead.write(xs).then(STM<Optional<A>>.pure(.some(x)))
+				case .Cons(let x, let xs):
+          return self.readHead.write({ TVar(xs) }).then(STM<Optional<A>>.pure(.some(x)))
 				}
 			}
 		}
@@ -99,11 +94,11 @@ public struct TChan<A> {
 	/// channel, retrying on failure.
 	public func peek() -> STM<A> {
 		return self.readHead.read().flatMap { hd in
-			return hd.read().flatMap { lst in
-				switch lst {
-				case .tNil:
+			return hd().read().flatMap { lst in
+				switch lst.match {
+				case .Nil:
 					return STM.retry()
-				case .tCons(let x, _):
+				case .Cons(let x, _):
 					return STM<A>.pure(x)
 				}
 			}
@@ -114,11 +109,11 @@ public struct TChan<A> {
 	/// channel without retrying.
 	public func tryPeek() -> STM<Optional<A>> {
 		return self.readHead.read().flatMap { hd in
-			return hd.read().flatMap { lst in
-				switch lst {
-				case .tNil:
+			return hd().read().flatMap { lst in
+				switch lst.match {
+				case .Nil:
 					return STM<Optional<A>>.pure(.none)
-				case .tCons(let x, _):
+				case .Cons(let x, _):
 					return STM<Optional<A>>.pure(.some(x))
 				}
 			}
@@ -132,28 +127,29 @@ public struct TChan<A> {
 	/// broadcast channel, where data written by anyone is seen by everyone else.
 	public func duplicate() -> STM<TChan<A>> {
 		return self.writeHead.read().flatMap { hd in
-			let newread = TVar(hd)
-			return STM<TChan<A>>.pure(TChan(newread, self.writeHead))
+      let newread = TVar({ hd })
+      return STM<TChan<A>>.pure(TChan(newread, self.writeHead))
 		}
 	}
 
 	/// Uses an STM transaction to atomically put a data item back onto a
 	/// channel, where it will be the next item read.
 	public func unGet(_ x : A) -> STM<()> {
 		return self.readHead.read().flatMap { hd in
-			let newhd = TVar(TList.tCons(x, hd))
-			return self.readHead.write(newhd)
+      return hd().read().flatMap { head in
+        return self.readHead.write({ TVar([x] + head) })
+      }
 		}
 	}
 
 	/// Uses an STM transaction to return whether the channel is empty.
 	public var isEmpty : STM<Bool> {
 		return self.readHead.read().flatMap { hd in
-			return hd.read().flatMap { lst in
-				switch lst {
-				case .tNil:
+			return hd().read().flatMap { lst in
+				switch lst.match {
+				case .Nil:
 					return STM<Bool>.pure(true)
-				case .tCons(_, _):
+				case .Cons(_, _):
 					return STM<Bool>.pure(false)
 				}
 			}
@@ -172,6 +168,24 @@ public struct TChan<A> {
 	}
 }
 
-private func undefined<A>() -> A {
-	fatalError("")
+private func undefined<A>(_ msg : String) -> A {
+	fatalError(msg)
+}
+
+extension Array {
+  fileprivate var match : ArrayMatcher<Element> {
+    if self.count == 0 {
+      return .Nil
+    } else if self.count == 1 {
+      return .Cons(self[0], [])
+    }
+    let hd = self[0]
+    let tl = Array(self[1..<self.count])
+    return .Cons(hd, tl)
+  }
+}
+
+private enum ArrayMatcher<A> {
+  case Nil
+  case Cons(A, [A])
 }