work on parsing stuff

SwiftIO/SocketEngine.swift

@@ -176,10 +176,10 @@ public class SocketEngine: NSObject, WebSocketDelegate {
                 
                 return
             }
+            
             // println(data)
             
-            if let str = NSString(data: data, encoding: NSUTF8StringEncoding) as? String {
+            if let str = NSString(data: data, encoding: NSUTF8StringEncoding) {
-                // println(str)
                 dispatch_async(self!.parseQueue) {callback(str)}
             }
             
@@ -221,7 +221,6 @@ public class SocketEngine: NSObject, WebSocketDelegate {
         
         for packet in self.postWait {
             let len = countElements(packet)
-            
             postStr += "\(len):\(packet)"
         }
         
@@ -230,14 +229,14 @@ public class SocketEngine: NSObject, WebSocketDelegate {
         let req = NSMutableURLRequest(URL: NSURL(string: self.urlPolling! + "&sid=\(self.sid)")!)
         
         req.HTTPMethod = "POST"
-        req.setValue("application/html-text", forHTTPHeaderField: "Content-Type")
+        req.setValue("text/plain; charset=UTF-8", forHTTPHeaderField: "Content-Type")
         
         let postData = postStr.dataUsingEncoding(NSUTF8StringEncoding,
             allowLossyConversion: false)!
         
-        // println("posting: \(postStr)")
+        // NSLog("posting: \(postStr)")
-        req.setValue(String(postData.length), forHTTPHeaderField: "Content-Length")
         req.HTTPBody = postData
+        req.setValue(String(postData.length), forHTTPHeaderField: "Content-Length")
         
         self.waitingForPost = true
         self.session.dataTaskWithRequest(req) {[weak self] data, res, err in
@@ -299,9 +298,8 @@ public class SocketEngine: NSObject, WebSocketDelegate {
                 return
             }
             
-            if let dataString = NSString(data: data, encoding: NSUTF8StringEncoding) {
+            if let dataString = NSString(data: data, encoding: NSUTF8StringEncoding) as? String {
-                var mutString = RegexMutable(dataString)
+                let parsed:[String]? = dataString["(\\d*):(\\d)(\\{.*\\})?"].groups()
-                let parsed:[String]? = mutString["(\\d*):(\\d)(\\{.*\\})?"].groups()
                 
                 if parsed == nil || parsed?.count != 4 {
                     return
@@ -406,17 +404,15 @@ public class SocketEngine: NSObject, WebSocketDelegate {
     }
     
     private func parseEngineMessage(var message:String) {
-        // println("Engine got message: \(message)")
+        // NSLog("Engine got message: \(message)")
-        
-        var strMessage = RegexMutable(message)
         
         // We should upgrade
-        if strMessage == "3probe" {
+        if message == "3probe" {
             self.upgradeTransport()
             return
         }
         
-        let type = strMessage["^(\\d)"].groups()?[1]
+        let type = message["^(\\d)"].groups()?[1]
         
         if type != PacketType.MESSAGE.rawValue {
             // TODO Handle other packets

SwiftIO/SocketEvent.swift

@@ -173,8 +173,7 @@ class SocketEvent {
             } else if let dict = arr[i] as? NSDictionary {
                 newArr[i] = self.fillInDict(dict)
             } else if let str = arr[i] as? String {
-                let mut = RegexMutable(str)
+                if let num = str["~~(\\d)"].groups() {
-                if let num = mut["~~(\\d)"].groups() {
                     newArr[i] = self.datas[num[1].toInt()!]
                 } else {
                     newArr[i] = arr[i]
@@ -196,9 +195,7 @@ class SocketEvent {
             // If the value is a string we need to check
             // if it is a placeholder for data
             if let str = value as? String {
-                let mut = RegexMutable(str)
+                if let num = str["~~(\\d)"].groups() {
-                
-                if let num = mut["~~(\\d)"].groups() {
                     newDict[key as String] = self.datas[num[1].toInt()!]
                 } else {
                     newDict[key as String] = str
@@ -231,9 +228,7 @@ class SocketEvent {
                 
                 for i in 0..<parsedArr.count {
                     if let str = parsedArr[i] as? String {
-                        let mut = RegexMutable(str)
+                        if let num = str["~~(\\d)"].groups() {
-                        
-                        if let num = mut["~~(\\d)"].groups() {
                             returnArr[i] = self.datas[num[1].toInt()!]
                         } else {
                             returnArr[i] = str

SwiftIO/SocketIOClient.swift

@@ -25,7 +25,7 @@
 import Foundation
 
 public class SocketIOClient: NSObject {
-    let socketURL:NSMutableString!
+    let socketURL:String!
     let ackQueue = dispatch_queue_create("ackQueue".cStringUsingEncoding(NSUTF8StringEncoding),
         DISPATCH_QUEUE_SERIAL)
     let handleQueue = dispatch_queue_create("handleQueue".cStringUsingEncoding(NSUTF8StringEncoding),
@@ -74,17 +74,15 @@ public class SocketIOClient: NSObject {
         return self._sid
     }
     
-    public init(socketURL:String, opts:[String: AnyObject]? = nil) {
+    public init(var socketURL:String, opts:[String: AnyObject]? = nil) {
-        var mutURL = RegexMutable(socketURL)
+        if socketURL["https://"].matches().count != 0 {
-        
-        if mutURL["https://"].matches().count != 0 {
             self._secure = true
         }
         
-        mutURL = mutURL["http://"] ~= ""
+        socketURL = socketURL["http://"] ~= ""
-        mutURL = mutURL["https://"] ~= ""
+        socketURL = socketURL["https://"] ~= ""
         
-        self.socketURL = mutURL
+        self.socketURL = socketURL
         
         // Set options
         if opts != nil {
@@ -396,6 +394,7 @@ public class SocketIOClient: NSObject {
         
         if self.reconnectTimer == nil {
             self._reconnecting = true
+            
             dispatch_async(dispatch_get_main_queue()) {[weak self] in
                 if self == nil {
                     return

SwiftIO/SocketParser.swift

@@ -186,7 +186,11 @@ class SocketParser {
     
     // Parses messages recieved
     class func parseSocketMessage(stringMessage:String, socket:SocketIOClient) {
-        // println(message!)
+        if stringMessage == "" {
+            return
+        }
+        
+        // NSLog(stringMessage)
         
         // Check for successful namepsace connect
         if socket.nsp != nil {
@@ -207,21 +211,33 @@ class SocketParser {
             }
         }
         
-        var mutMessage = RegexMutable(stringMessage)
+        if stringMessage.hasPrefix("5") {
+            // Check for message with binary placeholders
+            self.parseBinaryMessage(stringMessage, socket: socket)
+            return
+        }
+        
         
         /**
         Begin check for message
         **/
-        let messageGroups = mutMessage["(\\d*)\\/?(\\w*)?,?(\\d*)?(\\[.*\\])?"].groups()
+        let messageGroups = stringMessage["(\\d*)\\/?(\\w*)?,?(\\d*)?\\[\"(.*?)\",?(.*?)?\\]$"].groups()
+        if messageGroups == nil {
+            NSLog("Error in groups")
+            return
+        }
         
-        if messageGroups[1].hasPrefix("2") {
+        //        let messageGroups = SwiftRegex(target: stringMessage as NSString,
-            var mesNum = messageGroups[1]
+        //            pattern: "(\\d*)\\/?(\\w*)?,?(\\d*)?\\[\"(.*?)\",?(.*?)?\\]$",
+        //            options: NSRegularExpressionOptions.DotMatchesLineSeparators).groups()
+        
+        if messageGroups![1].hasPrefix("2") {
+            var mesNum = messageGroups![1]
             var ackNum:String
             var namespace:String?
-            var messagePart:String!
             
-            if messageGroups[3] != "" {
+            if messageGroups![3] != "" {
-                ackNum = messageGroups[3]
+                ackNum = messageGroups![3]
             } else {
                 let range = Range<String.Index>(start: mesNum.startIndex,
                     end: advance(mesNum.startIndex, 1))
@@ -229,26 +245,15 @@ class SocketParser {
                 ackNum = mesNum
             }
             
-            namespace = messageGroups[2]
+            namespace = messageGroups![2]
-            messagePart = messageGroups[4]
             
             if namespace == "" && socket.nsp != nil {
                 return
             }
             
-            let messageInternals = RegexMutable(messagePart)["\\[\"(.*?)\",(.*?)?\\]$"].groups()
+            let event = messageGroups![4]
-            if messageInternals != nil && messageInternals.count > 2 {
+            let data = "[\(messageGroups![5])]"
-                let event = messageInternals[1]
-                var data:String?
             
-                if messageInternals[2] == "" {
-                    data = nil
-                } else {
-                    data = messageInternals[2]
-                }
-                
-                // It would be nice if socket.io only allowed one thing
-                // per message, but alas, it doesn't.
             if let parsed:AnyObject = self.parseData(data) {
                 if ackNum == "" {
                     socket.handleEvent(event, data: parsed)
@@ -259,42 +264,11 @@ class SocketParser {
                 }
                 
                 return
-                } else if let strData = data {
-                    // There are multiple items in the message
-                    // Turn it into a String and run it through
-                    // parseData to try and get an array.
-                    let asArray = "[\(strData)]"
-                    if let parsed:AnyObject = self.parseData(asArray) {
-                        if ackNum == "" {
-                            socket.handleEvent(event, data: parsed)
-                        } else {
-                            socket.currentAck = ackNum.toInt()!
-                            socket.handleEvent(event, data: parsed, isInternalMessage: false,
-                                wantsAck: ackNum.toInt(), withAckType: 3)
             }
-                        
+        } else if messageGroups![1].hasPrefix("3") {
-                        return
+            let arr = Array(messageGroups![1])
-                    }
-                }
-            }
-            
-            // Check for no item event
-            let noItemMessage = RegexMutable(messagePart)["\\[\"(.*?)\"]$"].groups()
-            if noItemMessage != nil && noItemMessage.count == 2 {
-                let event = noItemMessage[1]
-                if ackNum == "" {
-                    socket.handleEvent(event, data: nil)
-                } else {
-                    socket.currentAck = ackNum.toInt()!
-                    socket.handleEvent(event, data: nil, isInternalMessage: false,
-                        wantsAck: ackNum.toInt(), withAckType: 3)
-                }
-                return
-            }
-        } else if messageGroups[1].hasPrefix("3") {
-            let arr = Array(messageGroups[1])
             var ackNum:String
-            let nsp = messageGroups[2]
+            let nsp = messageGroups![2]
             
             if nsp == "" && socket.nsp != nil {
                 return
@@ -303,10 +277,10 @@ class SocketParser {
             if nsp == "" {
                 ackNum = String(arr[1...arr.count-1])
             } else {
-                ackNum = messageGroups[3]
+                ackNum = messageGroups![3]
             }
             
-            let ackData:AnyObject? = self.parseData(messageGroups[4])
+            let ackData:AnyObject? = self.parseData(messageGroups![4])
             socket.handleAck(ackNum.toInt()!, data: ackData)
             
             return
@@ -314,13 +288,11 @@ class SocketParser {
         /**
         End Check for message
         **/
-        
-        // Check for message with binary placeholders
-        self.parseBinaryMessage(stringMessage, socket: socket)
     }
     
     // Handles binary data
     class func parseBinaryData(data:NSData, socket:SocketIOClient) {
+        // NSLog(data.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.allZeros))
         let shouldExecute = socket.waitingData[0].addData(data)
         
         if shouldExecute {
@@ -366,39 +338,41 @@ class SocketParser {
     
     // Tries to parse a message that contains binary
     class func parseBinaryMessage(message:String, socket:SocketIOClient) {
-        // println(message)
+        // NSLog(message)
-        var mutMessage = RegexMutable(message)
         
         /**
         Begin check for binary placeholders
         **/
-        let binaryGroup = mutMessage["^(\\d*)-\\/?(\\w*)?,?(\\d*)?\\[(\".*?\")?,?(.*)?\\]$"].groups()
+        let binaryGroup = message["^(\\d*)-\\/?(\\w*)?,?(\\d*)?\\[(\".*?\")?,?(.*)?\\]$"].groups()
+        //    let binaryGroup = SwiftRegex(target: message,
+        //        pattern: "^(\\d*)-\\/?(\\w*)?,?(\\d*)?\\[(\".*?\")?,?(.*)?\\]$",
+        //        options: NSRegularExpressionOptions.DotMatchesLineSeparators).groups()
         
         if binaryGroup == nil {
             return
         }
         
-        if binaryGroup[1].hasPrefix("5") {
+        if binaryGroup![1].hasPrefix("5") {
             // println(binaryGroup)
             var ackNum:String
             var event:String
-            var mutMessageObject:NSMutableString
+            var mutMessageObject:String
             var namespace:String?
             var numberOfPlaceholders:String
-            let messageType = RegexMutable(binaryGroup[1])
+            let messageType = binaryGroup![1]
             
-            namespace = binaryGroup[2]
+            namespace = binaryGroup![2]
-            if binaryGroup[3] != "" {
+            if binaryGroup![3] != "" {
-                ackNum = binaryGroup[3] as String
+                ackNum = binaryGroup![3] as String
-            } else if socket.nsp == nil && binaryGroup[2] != "" {
+            } else if socket.nsp == nil && binaryGroup![2] != "" {
-                ackNum = binaryGroup[2]
+                ackNum = binaryGroup![2]
             } else {
                 ackNum = ""
             }
             
             numberOfPlaceholders = (messageType["5"] ~= "") as String
-            event = (RegexMutable(binaryGroup[4])["\""] ~= "") as String
+            event = (binaryGroup![4]["\""] ~= "") as String
-            mutMessageObject = RegexMutable(binaryGroup[5])
+            mutMessageObject = binaryGroup![5]
             
             if namespace == "" && socket.nsp != nil {
                 return
@@ -418,24 +392,24 @@ class SocketParser {
             }
             
             socket.waitingData.append(mes)
-        } else if binaryGroup[1].hasPrefix("6") {
+        } else if binaryGroup![1].hasPrefix("6") {
-            let messageType = RegexMutable(binaryGroup[1])
+            let messageType = binaryGroup![1]
             let numberOfPlaceholders = (messageType["6"] ~= "") as String
             var ackNum:String
             var nsp:String
             
-            if binaryGroup[3] == "" {
+            if binaryGroup![3] == "" {
-                ackNum = binaryGroup[2]
+                ackNum = binaryGroup![2]
                 nsp = ""
             } else {
-                ackNum = binaryGroup[3]
+                ackNum = binaryGroup![3]
-                nsp = binaryGroup[2]
+                nsp = binaryGroup![2]
             }
             
             if nsp == "" && socket.nsp != nil {
                 return
             }
-            var mutMessageObject = RegexMutable(binaryGroup[5])
+            var mutMessageObject = binaryGroup![5]
             let placeholdersRemoved = mutMessageObject["(\\{\"_placeholder\":true,\"num\":(\\d*)\\})"]
                 ~= "\"~~$2\""
             

SwiftIO/SwiftRegex.swift

@@ -16,11 +16,10 @@ import Foundation
 var swiftRegexCache = [String: NSRegularExpression]()
 
 public class SwiftRegex: NSObject, BooleanType {
-    
+    var target:String
-    var target: NSString
     var regex: NSRegularExpression
     
-    init(target:NSString, pattern:String, options:NSRegularExpressionOptions = nil) {
+    init(target:String, pattern:String, options:NSRegularExpressionOptions = nil) {
         self.target = target
         if let regex = swiftRegexCache[pattern] {
             self.regex = regex
@@ -44,12 +43,12 @@ public class SwiftRegex: NSObject, BooleanType {
     }
     
     final var targetRange: NSRange {
-        return NSRange(location: 0,length: target.length)
+        return NSRange(location: 0,length: countElements(target))
     }
     
-    final func substring(range: NSRange) -> NSString! {
+    final func substring(range: NSRange) -> String? {
         if ( range.location != NSNotFound ) {
-            return target.substringWithRange(range)
+            return (target as NSString).substringWithRange(range)
         } else {
             return nil
         }
@@ -63,19 +62,19 @@ public class SwiftRegex: NSObject, BooleanType {
         return regex.rangeOfFirstMatchInString(target as String, options: nil, range: targetRange)
     }
     
-    public func match(options: NSMatchingOptions = nil) -> String! {
+    public func match(options: NSMatchingOptions = nil) -> String? {
-        return substring(range(options: options)) as String
+        return substring(range(options: options))
     }
     
-    public func groups(options: NSMatchingOptions = nil) -> [String]! {
+    public func groups(options: NSMatchingOptions = nil) -> [String]? {
-        return groupsForMatch( regex.firstMatchInString(target as String, options: options, range: targetRange) )
+        return groupsForMatch(regex.firstMatchInString(target as String, options: options, range: targetRange))
     }
     
-    func groupsForMatch(match: NSTextCheckingResult!) -> [String]! {
+    func groupsForMatch(match: NSTextCheckingResult!) -> [String]? {
         if match != nil {
             var groups = [String]()
             for groupno in 0...regex.numberOfCaptureGroups {
-                if let group = substring(match.rangeAtIndex(groupno)) as String! {
+                if let group = substring(match.rangeAtIndex(groupno)) {
                     groups += [group]
                 } else {
                     groups += ["_"] // avoids bridging problems
@@ -87,19 +86,23 @@ public class SwiftRegex: NSObject, BooleanType {
         }
     }
     
-    public subscript(groupno: Int) -> String! {
+    public subscript(groupno: Int) -> String? {
         get {
-            return groups()[groupno]
+            return groups()?[groupno]
         }
+        
         set(newValue) {
-            if let mutableTarget = target as? NSMutableString {
+            if newValue == nil {
-                for match in matchResults()!.reverse() {
+                return
-                    let replacement = regex.replacementStringForResult( match,
-                        inString: target as String, offset: 0, template: newValue )
-                    mutableTarget.replaceCharactersInRange(match.rangeAtIndex(groupno), withString: replacement)
             }
-            } else {
+            
-                SwiftRegex.failure("Group modify on non-mutable")
+            for match in matchResults()!.reverse() {
+                let replacement = regex.replacementStringForResult(match,
+                    inString: target as String, offset: 0, template: newValue!)
+                let mut = NSMutableString(string: target)
+                mut.replaceCharactersInRange(match.rangeAtIndex(groupno), withString: replacement)
+                
+                target = mut
             }
         }
     }
@@ -120,24 +123,23 @@ public class SwiftRegex: NSObject, BooleanType {
     }
     
     public func matches(options: NSMatchingOptions = nil) -> [String] {
-        return matchResults(options: options)!.map( { self.substring($0.range) as String } )
+        return matchResults(options: options)!.map( { self.substring($0.range)!})
     }
     
-    public func allGroups(options: NSMatchingOptions = nil) -> [[String]] {
+    public func allGroups(options: NSMatchingOptions = nil) -> [[String]?] {
-        return matchResults(options: options)!.map { self.groupsForMatch($0) }
+        return matchResults(options: options)!.map {self.groupsForMatch($0)}
     }
     
     public func dictionary(options: NSMatchingOptions = nil) -> Dictionary<String,String> {
         var out = Dictionary<String,String>()
         for match in matchResults(options: options)! {
-            out[substring(match.rangeAtIndex(1)) as String] =
+            out[substring(match.rangeAtIndex(1))!] = substring(match.rangeAtIndex(2))!
-                substring(match.rangeAtIndex(2))
         }
         return out
     }
     
     func substituteMatches(substitution: (NSTextCheckingResult, UnsafeMutablePointer<ObjCBool>) -> String,
-        options:NSMatchingOptions = nil) -> NSMutableString {
+        options:NSMatchingOptions = nil) -> String {
             let out = NSMutableString()
             var pos = 0
             
@@ -145,63 +147,21 @@ public class SwiftRegex: NSObject, BooleanType {
                 (match: NSTextCheckingResult!, flags: NSMatchingFlags, stop: UnsafeMutablePointer<ObjCBool>) in
                 
                 let matchRange = match.range
-                out.appendString( self.substring( NSRange(location:pos, length:matchRange.location-pos) ) as String )
+                out.appendString( self.substring(NSRange(location:pos, length:matchRange.location-pos))!)
                 out.appendString( substitution(match, stop) )
                 pos = matchRange.location + matchRange.length
             }
             
-            out.appendString( substring( NSRange(location:pos, length:targetRange.length-pos) ) as String )
+            out.appendString(substring( NSRange(location:pos, length:targetRange.length-pos))!)
             
-            if let mutableTarget = target as? NSMutableString {
-                mutableTarget.setString(out as String)
-                return mutableTarget
-            } else {
-                SwiftRegex.failure("Modify on non-mutable")
             return out
     }
-    }
-    /* removed Beta6
-    public func __conversion() -> Bool {
-    return doesMatch()
-    }
     
-    public func __conversion() -> NSRange {
-    return range()
-    }
-    
-    public func __conversion() -> String {
-    return match()
-    }
-    
-    public func __conversion() -> [String] {
-    return matches()
-    }
-    
-    public func __conversion() -> [[String]] {
-    return allGroups()
-    }
-    
-    public func __conversion() -> [String:String] {
-    return dictionary()
-    }
-    */
     public var boolValue: Bool {
         return doesMatch()
     }
 }
 
-extension NSString {
-    public subscript(pattern: String, options: NSRegularExpressionOptions) -> SwiftRegex {
-        return SwiftRegex(target: self, pattern: pattern, options: options)
-    }
-}
-
-extension NSString {
-    public subscript(pattern: String) -> SwiftRegex {
-        return SwiftRegex(target: self, pattern: pattern)
-    }
-}
-
 extension String {
     public subscript(pattern: String, options: NSRegularExpressionOptions) -> SwiftRegex {
         return SwiftRegex(target: self, pattern: pattern, options: options)
@@ -214,18 +174,14 @@ extension String {
     }
 }
 
-public func RegexMutable(string: NSString) -> NSMutableString {
+public func ~= (left: SwiftRegex, right: String) -> String {
-    return NSMutableString(string:string as String)
-}
-
-public func ~= (left: SwiftRegex, right: String) -> NSMutableString {
     return left.substituteMatches({match, stop in
         return left.regex.replacementStringForResult( match,
             inString: left.target as String, offset: 0, template: right )
         }, options: nil)
 }
 
-public func ~= (left: SwiftRegex, right: [String]) -> NSMutableString {
+public func ~= (left: SwiftRegex, right: [String]) -> String {
     var matchNumber = 0
     return left.substituteMatches({match, stop -> String in
         
@@ -238,92 +194,16 @@ public func ~= (left: SwiftRegex, right: [String]) -> NSMutableString {
         }, options: nil)
 }
 
-public func ~= (left: SwiftRegex, right: (String) -> String) -> NSMutableString {
+public func ~= (left: SwiftRegex, right: (String) -> String) -> String {
     // return right(left.substring(match.range))
     return left.substituteMatches(
         {match, stop -> String in
-            right(left.substring(match.range) as String)
+            right(left.substring(match.range)!)
         }, options: nil)
 }
 
-public func ~= (left: SwiftRegex, right: ([String]) -> String) -> NSMutableString {
+public func ~= (left: SwiftRegex, right: ([String]?) -> String) -> String {
     return left.substituteMatches({match, stop -> String in
         return right(left.groupsForMatch(match))
         }, options: nil)
 }
-
-// my take on custom threading operators from
-// http://ijoshsmith.com/2014/07/05/custom-threading-operator-in-swift/
-
-private let _queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
-
-public func | (left: () -> Void, right: () -> Void) {
-    dispatch_async(_queue) {
-        left()
-        dispatch_async(dispatch_get_main_queue(), right)
-    }
-}
-
-public func | <R> (left: () -> R, right: (result:R) -> Void) {
-    dispatch_async(_queue) {
-        let result = left()
-        dispatch_async(dispatch_get_main_queue(), {
-            right(result:result)
-        })
-    }
-}
-
-// dispatch groups { block } & { block } | { completion }
-public func & (left: () -> Void, right: () -> Void) -> [() -> Void] {
-    return [left, right];
-}
-
-public func & (left: [() -> Void], right: () -> Void) -> [() -> Void] {
-    var out = left
-    out.append( right )
-    return out
-}
-
-public func | (left: [() -> Void], right: () -> Void) {
-    let group = dispatch_group_create()
-    
-    for block in left {
-        dispatch_group_async(group, _queue, block)
-    }
-    
-    dispatch_group_notify(group, dispatch_get_main_queue(), right)
-}
-
-// parallel blocks with returns
-public func & <R> (left: () -> R, right: () -> R) -> [() -> R] {
-    return [left, right]
-}
-
-public func & <R> (left: [() -> R], right: () -> R) -> [() -> R] {
-    var out = left
-    out.append( right )
-    return out
-}
-
-public func | <R> (left: [() -> R], right: (results:[R!]) -> Void) {
-    let group = dispatch_group_create()
-    
-    var results = Array<R!>()
-    for t in 0..<left.count {
-        results += [nil]
-    }
-    
-    for t in 0..<left.count {
-        //dispatch_retain(group)
-        dispatch_group_enter(group)
-        dispatch_async(_queue, {
-            results[t] = left[t]()
-            dispatch_group_leave(group)
-            //dispatch_release(group)
-        })
-    }
-    
-    dispatch_group_notify(group, dispatch_get_main_queue(), {
-        right(results: results)
-    })
-}