Merge remote-tracking branch 'reactive-swift/master' into develop

Author: killev

Cartfile

@@ -1,3 +1,2 @@
-github "antitypical/Result" ~> 2.0
-github "crossroadlabs/Boilerplate" ~> 0.1
-github "reactive-swift/RunLoop" "master"
+github "crossroadlabs/Boilerplate" ~> 1.0
+github "reactive-swift/RunLoop" ~> 1.0

Cartfile.private

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0720"
+   LastUpgradeVersion = "0800"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"

ExecutionContext.xcodeproj/project.pbxproj

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0730"
+   LastUpgradeVersion = "0800"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"

ExecutionContext.xcodeproj/xcshareddata/xcschemes/ExecutionContext-OSX.xcscheme

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0730"
+   LastUpgradeVersion = "0800"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"

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

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0730"
+   LastUpgradeVersion = "0800"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"

ExecutionContext.xcodeproj/xcshareddata/xcschemes/ExecutionContext-tvOS.xcscheme

@@ -15,18 +15,17 @@
 //===----------------------------------------------------------------------===//
 
 import Foundation
-import Foundation3
 import Boilerplate
 
-public class CustomExecutionContext : ExecutionContextBase, ExecutionContextType {
+public class CustomExecutionContext : ExecutionContextBase, ExecutionContextProtocol {
     let id = NSUUID()
     let executor:Executor
 
-    public init(executor:Executor) {
+    public init(executor:@escaping Executor) {
         self.executor = executor
     }
 
-    public func async(task:SafeTask) {
+    public func async(task:@escaping SafeTask) {
         executor {
             let context = currentContext.value
             defer {
@@ -38,21 +37,21 @@ public class CustomExecutionContext : ExecutionContextBase, ExecutionContextType
         }
     }
 
-    public func async(after:Timeout, task:SafeTask) {
+    public func async(after:Timeout, task:@escaping SafeTask) {
         async {
-            Thread.sleep(after)
+            Thread.sleep(timeout: after)
             task()
         }
     }
 
-    public func sync<ReturnType>(task:() throws -> ReturnType) rethrows -> ReturnType {
-        return try syncThroughAsync(task)
+    public func sync<ReturnType>(task:@escaping TaskWithResult<ReturnType>) rethrows -> ReturnType {
+        return try syncThroughAsync(task: task)
     }
 
-    public func isEqualTo(other: NonStrictEquatable) -> Bool {
+    public func isEqual(to other: NonStrictEquatable) -> Bool {
         guard let other = other as? CustomExecutionContext else {
             return false
         }
         return id.isEqual(other.id)
     }
-}
+}

ExecutionContext.xcodeproj/xcshareddata/xcschemes/ExecutionContext-watchOS.xcscheme

@@ -18,10 +18,10 @@ import Foundation
 
 #if !os(Linux) || dispatch
 
-    #if nouv
-        public typealias DefaultExecutionContext = DispatchExecutionContext
-    #else
+    #if uv
         public typealias DefaultExecutionContext = RunLoopExecutionContext
+    #else
+        public typealias DefaultExecutionContext = DispatchExecutionContext
     #endif
 
 #else
@@ -36,18 +36,17 @@ import Foundation
 
 #endif
 
-public protocol DefaultExecutionContextType : ExecutionContextType {
+public protocol DefaultExecutionContextProtocol : ExecutionContextProtocol {
     init(kind:ExecutionContextKind)
 
-    static var main:ExecutionContextType {
+    static var main:ExecutionContextProtocol {
         get
     }
 
-    static var global:ExecutionContextType {
+    static var global:ExecutionContextProtocol {
         get
     }
 
     /// unfortunately name main() is not allowed
-    @noreturn
-    static func mainProc()
-}
+    static func mainProc() -> Never
+}

ExecutionContext/CustomExecutionContext.swift

@@ -17,54 +17,53 @@
 #if !os(Linux) || dispatch
 
     import Foundation
-    import Foundation3
     import Dispatch
     import Boilerplate
     import RunLoop
 
     private extension ExecutionContextKind {
-        func createDispatchQueue(id:String) -> dispatch_queue_t! {
+        func createDispatchQueue(id:String) -> DispatchQueue {
             switch self {
             case .serial:
-                return dispatch_queue_create(id, DISPATCH_QUEUE_SERIAL)
+                return DispatchQueue(label: id)
             case .parallel:
-                return dispatch_queue_create(id, DISPATCH_QUEUE_CONCURRENT)
+                return DispatchQueue(label: id, attributes: .concurrent)
             }
         }
     }
 
-    public class DispatchExecutionContext : ExecutionContextBase, ExecutionContextType, DefaultExecutionContextType {
+    public class DispatchExecutionContext : ExecutionContextBase, ExecutionContextProtocol, DefaultExecutionContextProtocol {
         private let loop:DispatchRunLoop
 
         public required convenience init(kind:ExecutionContextKind) {
             let id = NSUUID().uuidString
-            let queue = kind.createDispatchQueue(id)
+            let queue = kind.createDispatchQueue(id: id)
             self.init(queue: queue)
         }
 
-        public init(queue:dispatch_queue_t) {
+        public init(queue:DispatchQueue) {
             self.loop = DispatchRunLoop(queue: queue)
             super.init()
             loop.execute {
                 currentContext.value = self
             }
         }
 
-        public func async(task:SafeTask) {
+        public func async(task:@escaping SafeTask) {
             loop.execute {
                 currentContext.value = self
                 task()
             }
         }
 
-        public func async(after:Timeout, task:SafeTask) {
-            loop.execute(after) {
+        public func async(after:Timeout, task:@escaping SafeTask) {
+            loop.execute(delay: after) {
                 currentContext.value = self
                 task()
             }
         }
 
-        public func sync<ReturnType>(task:() throws -> ReturnType) rethrows -> ReturnType {
+        public func sync<ReturnType>(task:@escaping TaskWithResult<ReturnType>) rethrows -> ReturnType {
             if isCurrent {
                 return try task()
             }
@@ -75,24 +74,23 @@
             }
         }
 
-        public static let main:ExecutionContextType = DispatchExecutionContext(queue: dispatch_get_main_queue())
-        public static let global:ExecutionContextType = DispatchExecutionContext(queue: dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0))
+        public static let main:ExecutionContextProtocol = DispatchExecutionContext(queue: .main)
+        public static let global:ExecutionContextProtocol = DispatchExecutionContext(queue: .global())
 
-        @noreturn
-        public static func mainProc() {
+        public static func mainProc() -> Never  {
             if !Thread.isMain {
                 print("Main proc was called on non-main thread. Exiting")
                 exit(1)
             }
-            dispatch_main()
+            dispatchMain()
         }
 
-        public func isEqualTo(other: NonStrictEquatable) -> Bool {
+        public func isEqual(to other: NonStrictEquatable) -> Bool {
             guard let other = other as? DispatchExecutionContext else {
                 return false
             }
-            return loop.isEqualTo(other.loop)
+            return loop.isEqual(to: other.loop)
         }
     }
 
-#endif
+#endif