Merge pull request #25 from CodaFi/big-merge

Update to Swift 2.0

.gitignore

@@ -16,6 +16,8 @@ DerivedData
 *.hmap
 *.ipa
 *.xcuserstate
+*.xcscmblueprint
+Cartfile.resolved
 Carthage/
 
 # CocoaPods

.gitmodules

@@ -1,6 +1,3 @@
-[submodule "Carthage/Checkouts/Swiftz"]
-	path = Carthage/Checkouts/Swiftz
-	url = https://github.com/typelift/Swiftz.git
 [submodule "Carthage/Checkouts/SwiftCheck"]
 	path = Carthage/Checkouts/SwiftCheck
 	url = https://github.com/typelift/SwiftCheck.git

.travis.yml

@@ -1,9 +1,12 @@
 language: objective-c
-osx_image: beta-xcode6.3
+osx_image: xcode7
+
+before_install:
+    - gem install xcpretty-travis-formatter --no-rdoc --no-ri --no-document --quiet
 
 install:
     - git submodule update -i --recursive
 
 script:
-    - xctool -project Concurrent.xcodeproj -scheme Concurrent -sdk macosx ONLY_ACTIVE_ARCH=NO clean build test
-    - xctool -project Concurrent.xcodeproj -scheme Concurrent-iOS -sdk iphonesimulator ONLY_ACTIVE_ARCH=NO clean build test
+    - set -o pipefail && xcodebuild -project Concurrent.xcodeproj -scheme Concurrent -sdk macosx ONLY_ACTIVE_ARCH=NO clean build test | xcpretty -c -f `xcpretty-travis-formatter`
+    - set -o pipefail && xcodebuild -project Concurrent.xcodeproj -scheme Concurrent-iOS -sdk iphonesimulator ONLY_ACTIVE_ARCH=NO clean build test | xcpretty -c -f `xcpretty-travis-formatter`

Cartfile.private

@@ -1,2 +1 @@
-github "typelift/Swiftz"
-github "typelift/SwiftCheck"
+github "typelift/SwiftCheck" 

Concurrent.xcodeproj/xcshareddata/xcschemes/Concurrent-iOS.xcscheme

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0630"
+   LastUpgradeVersion = "0700"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
@@ -62,6 +62,8 @@
             ReferencedContainer = "container:Concurrent.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
    </TestAction>
    <LaunchAction
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
@@ -71,6 +73,7 @@
       buildConfiguration = "Debug"
       ignoresPersistentStateOnLaunch = "NO"
       debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
       allowLocationSimulation = "YES">
       <MacroExpansion>
          <BuildableReference

Concurrent.xcodeproj/xcshareddata/xcschemes/Concurrent.xcscheme

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0610"
+   LastUpgradeVersion = "0700"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
@@ -62,6 +62,8 @@
             ReferencedContainer = "container:Concurrent.xcodeproj">
          </BuildableReference>
       </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
    </TestAction>
    <LaunchAction
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
@@ -71,6 +73,7 @@
       buildConfiguration = "Debug"
       ignoresPersistentStateOnLaunch = "NO"
       debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
       allowLocationSimulation = "YES">
       <MacroExpansion>
          <BuildableReference

Concurrent/Chan.swift

@@ -29,9 +29,13 @@ public struct Chan<A> {
 
 	/// Reads a value from the channel.
 	public func read() -> A {
-		return self.readEnd.modify { readEnd in
-			let item : ChItem<A> = readEnd.read()
-			return (item.stream(), item.val())
+		do {
+			return try self.readEnd.modify { readEnd in
+				let item : ChItem<A> = readEnd.read()
+				return (item.stream(), item.val())
+			}
+		} catch _ {
+			fatalError("Fatal: Could not modify read head.")
 		}
 	}
 
@@ -46,7 +50,7 @@ public struct Chan<A> {
 
 	/// Writes a list of values to a channel.
 	public func writeList(xs : [A]) {
-		xs.map({ self.write($0) })
+		xs.forEach(self.write)
 	}
 
 	/// Returns whether the channel is empty.
@@ -55,9 +59,13 @@ public struct Chan<A> {
 	/// concurrent computations, this may change out from under you without warning, or even by the
 	/// time it can be acted on.  It is better to use one of the direct actions above.
 	public var isEmpty : Bool {
-		return self.readEnd.withMVar { r in
-			let w = r.tryRead()
-			return w == nil
+		do {
+			return try self.readEnd.withMVar { r in
+				let w = r.tryRead()
+				return w == nil
+			}
+		} catch _ {
+			fatalError("Fatal: Could not determine emptiness; read of underlying MVar failed.")
 		}
 	}
 

Concurrent/Concurrent.swift

@@ -6,8 +6,6 @@
 //  Copyright (c) 2014 TypeLift. All rights reserved.
 //
 
-import Swiftz
-
 public typealias ThreadID = pthread_t
 
 public func myTheadID() -> ThreadID {
@@ -21,11 +19,10 @@ public func forkIO(@autoclosure(escaping) io :  () -> ()) -> ThreadID {
 	})
 }
 
-/// Forks a thread and calls the given function when the thread is about to terminate with either
-/// a value or an exception.
-public func forkFinally<A>(@autoclosure(escaping) io :  () -> A, finally : Either<Exception, A> -> ()) -> ThreadID {
-	return mask({ (let restore : A -> A) -> ThreadID in
-		return forkIO(finally(try(restore(io()))))
+/// Forks a computation onto a new thread and returns its thread ID.
+public func forkIO(io :  () -> ()) -> ThreadID {
+	return CONCRealWorld.forkWithStart({
+		return io()
 	})
 }
 

Concurrent/Future.swift

@@ -6,87 +6,88 @@
 //  Copyright (c) 2014 TypeLift. All rights reserved.
 //
 
-import Swiftz
-
 public struct Future<A> {
 	let threadID : MVar<Optional<ThreadID>>
-	let cResult : IVar<Result<A>>
-	let finalizers : MVar<[Result<A> -> ()]>
+	let completionLock : IVar<Optional<A>>
+	let finalizers : MVar<[Optional<A> -> ()]>
 
-	private init(_ threadID : MVar<Optional<ThreadID>>, _ cResult : IVar<Result<A>>, _ finalizers : MVar<[Result<A> -> ()]>) {
+	private init(_ threadID : MVar<Optional<ThreadID>>, _ cOptional : IVar<Optional<A>>, _ finalizers : MVar<[Optional<A> -> ()]>) {
 		self.threadID = threadID
-		self.cResult = cResult
+		self.completionLock = cOptional
 		self.finalizers = finalizers
 	}
 
-	public func read() -> Result<A> {
-		return self.cResult.read()
+	public func read() -> Optional<A> {
+		return self.completionLock.read()
 	}
 
-	public func then(finalize : Result<A> -> ()) -> Future<A> {
-		let ma : Optional<Result<A>> = self.finalizers.modify { sTodo in
-			let res = self.cResult.tryRead()
-			if res == nil {
-				return (sTodo + [finalize], res)
+	public func then(finalize : Optional<A> -> ()) -> Future<A> {
+		do {
+			let ma : Optional<Optional<A>> = try self.finalizers.modify { sTodo in
+				let res = self.completionLock.tryRead()
+				if res == nil {
+					return (sTodo + [finalize], res)
+				}
+				return (sTodo, res)
 			}
-			return (sTodo, res)
-		}
-
-		switch ma {
-		case .None:
-			return self
-		case .Some(let val):
-			self.runFinalizerWithResult(val)(finalize)
-			return self
+
+			switch ma {
+			case .None:
+				return self
+			case .Some(let val):
+				self.runFinalizerWithOptional(val)(finalize)
+				return self
+			}
+		} catch _ {
+			fatalError("Fatal: Could not read underlying MVar to spark finalizers.")
 		}
 	}
 
-	private func complete(r : Result<A>) -> Result<A> {
-		return self.cResult.tryPut(r) ? r : self.cResult.read()
+	private func complete(r : Optional<A>) -> Optional<A> {
+		return self.completionLock.tryPut(r) ? r : self.completionLock.read()
 	}
 
-	private func runFinalizerWithResult<A>(val : Result<A>) -> (Result<A> -> ()) -> ThreadID {
+	private func runFinalizerWithOptional<A>(val : Optional<A>) -> (Optional<A> -> ()) -> ThreadID {
 		return { todo in forkIO(todo(val)) }
 	}
 }
 
-public func forkFutures<A>(ios : [() -> A]) -> Chan<Result<A>> {
-	let c : Chan<Result<A>> = Chan()
-	let ps = ios.map({ forkFuture($0) }).map({ f in f.then({ c.write($0) }) })
+public func forkFutures<A>(ios : [() -> A]) -> Chan<Optional<A>> {
+	let c : Chan<Optional<A>> = Chan()
+	ios.map(forkFuture).forEach { f in f.then(c.write) }
 	return c
 }
 
-public func forkFuture<A>(io : () -> A) -> Future<A> {
-	let msTid : MVar<Optional<ThreadID>> = MVar()
-	let result : IVar<Result<A>> = IVar()
-	let msTodo : MVar<[Result<A> -> ()]> = MVar(initial: [])
+public func forkFuture<A>(io : () throws -> A) -> Future<A> {
+	let msTid = MVar<ThreadID?>()
+	let lock : IVar<A?> = IVar()
+	let msTodo : MVar<[A? -> ()]> = MVar(initial: [])
 
-	let p = Future(msTid, result, msTodo)
-	let act : dispatch_block_t = {
+	let p = Future(msTid, lock, msTodo)
+	let act : () -> () = {
 		p.threadID.put(.Some(myTheadID()))
-
-		let val : Result<A> = { r in
-			let res : Result<A> = r.toResult({ e in return NSError(domain: "", code: 0, userInfo: [ NSLocalizedDescriptionKey : e.description ]) })
-			return p.complete(res)
-		}(try(io()))
-
-		switch val {
-			case .Error(let err):
-				return error("")
-			case .Value(_):
-				return ()
-		}
+		_ = p.complete({
+			do {
+				return try io()
+			} catch _ {
+				return nil
+			}
+		}())
 	}
 
 	let process : dispatch_block_t = {
-		let paranoid = Result<A>.error(NSError(domain: "", code: 0, userInfo: nil))
-
-		p.threadID.modify_(const(.None))
+		let paranoid : A? = nil
+		p.threadID.modify_({ _ in .None })
 		let val = p.complete(paranoid)
 		let sTodo = p.finalizers.swap([])
-		let _ = sTodo.map(p.runFinalizerWithResult(val))
+		sTodo.forEach { _ in
+			let _ = p.runFinalizerWithOptional(val)
+		}
 	}
 
-	let thr = forkIO(finally(act())(then: process()))
+	_ = forkIO {
+		act()
+		process()
+	}
 	return p
 }

Concurrent/IChan.swift

@@ -41,7 +41,11 @@ public struct IChan<A> {
 	/// If the same head has been written to more than once, this function will throw an exception.
 	public func write(x : A) -> IChan<A> {
 		let ic = IChan()
-		self.ivar.put((x, ic))
+		do {
+			try self.ivar.put((x, ic))
+		} catch _ {
+			fatalError("Fatal: Accidentally wrote to the same IChan head twice.")
+		}
 		return ic
 	}