Ios 使用带有完成块的自定义运算符

简而言之，假设我定义了一个操作符：

infix operator <~ {
    associativity left
    precedence 160
}

---

infix操作符只要你愿意搭建一些脚手架，你就可以实现这一点。这是不可能开箱即用的

让我们考虑一下，在没有操作员的情况下，我们可以如何进行这项工作。我们将有一个操作队列，当每个操作完成时，我们将添加下一个。每次操作完成后都应通知队列

因此，操作员只负责将操作添加到队列中。如果您想要更复杂的实现，请查看Swift的任何承诺库。我已尝试将这一概念的初步工作落实到一起：

var queue = NSOperationQueue()

infix operator <~ {
    associativity left
    precedence 160
}

struct QueuedOperation
{
    var operation : NSBlockOperation
}


func <~ (first: ()->(), second:()->())->QueuedOperation {

    let operationOne = NSBlockOperation(block: first)
    let operationTwo = NSBlockOperation(block: second)

    operationTwo.addDependency(operationOne)
    queue.addOperation(operationOne)
    queue.addOperation(operationTwo)

    return QueuedOperation(operation: operationTwo)
}

func <~ (first : QueuedOperation, second:()->())->QueuedOperation {

    let operationTwo = NSBlockOperation(block: second)

    operationTwo.addDependency(first.operation)
    queue.addOperation(operationTwo)

    return QueuedOperation(operation: operationTwo)
}



_ = {

    sleep(2)

    print("First")

    } <~ {

        sleep(4)

        print("Second")

    } <~ {

        sleep(8)
        print("Third")
}

var queue=NSOperationQueue（）
中缀运算符（））->QueueDoOperation{
let operationOne=NSBlockOperation（块：第一个）
let operationTwo=NSBlockOperation（块：秒）
operationTwo.addDependency（operationOne）
queue.addOperation（operationOne）
queue.addOperation（操作二）
返回队列操作（操作：操作二）
}
func（））->QueueDoOperation{
let operationTwo=NSBlockOperation（块：秒）
operationTwo.addDependency（第一个操作）
queue.addOperation（操作二）
返回队列操作（操作：操作二）
}
_ = {
睡眠（2）
打印（“第一次”）
}不幸的是，

something <~ somethingElse {
    error in
    //async call finished
}

var queue = NSOperationQueue()

infix operator <~ {
    associativity left
    precedence 160
}

struct QueuedOperation
{
    var operation : NSBlockOperation
}


func <~ (first: ()->(), second:()->())->QueuedOperation {

    let operationOne = NSBlockOperation(block: first)
    let operationTwo = NSBlockOperation(block: second)

    operationTwo.addDependency(operationOne)
    queue.addOperation(operationOne)
    queue.addOperation(operationTwo)

    return QueuedOperation(operation: operationTwo)
}

func <~ (first : QueuedOperation, second:()->())->QueuedOperation {

    let operationTwo = NSBlockOperation(block: second)

    operationTwo.addDependency(first.operation)
    queue.addOperation(operationTwo)

    return QueuedOperation(operation: operationTwo)
}



_ = {

    sleep(2)

    print("First")

    } <~ {

        sleep(4)

        print("Second")

    } <~ {

        sleep(8)
        print("Third")
}

import Foundation

infix operator <~ {
associativity left
precedence 160
}

func <~(lhs: Int, rhs: Int) -> ((Int) -> Void) -> Void {
    return { callback in
        dispatch_async(dispatch_get_main_queue()) {
            callback(lhs + rhs)
        }
    }
}

let a = 1
let b = 2

(a <~ b) { result in
    println("OK: \(result)")
}

dispatch_main()