swift - 如果 PromiseKit promise 已经在运行，那么返回待定 PromiseKit promise 的最佳 Swift 模式是什么？

Question

我有一些昂贵的 promise ，在不同的地方被调用。理想情况下，我只想链接现有的飞行 promise (使用可选的强制)，所以我发现自己在做这样的事情:

class Expensive {
  var fooPromise : Promise<Foo>?
  var barPromise : Promise<Bar>?

  func doExpensiveFoo(force: bool = false) -> Promise<Foo> {
    if let existing = fooPromise where existing.pending || (existing.fufilled && !force) {
      // Return the existing promise
      return existing
    }

    // Start a new Foo
    return firstly {
       // ...
    }
  }

  func doExpensiveBar(force: bool = false) -> Promise<Bar> {
    if let existing = barPromise where existing.pending || (existing.fufilled && !force) {
      // Return the existing promise
      return existing
    }

    // Start a new Bar
    return firstly {
       // ...
    }
  }
}

但这感觉像是相当多的样板文件(每个 promise 的局部变量，以及每个函数开头的现有 block )，所以我想知道是否有人看到了一个很好的模式来抽象掉变量和包装器？

借用 Python 的一个术语，我正在寻找一个可以隐藏所有这些的装饰器。像这样的东西:

class Expensive {

  private func startFoo() -> Promise<Foo> {
    return firstly {
       //..
    }
  }

  public doExpensiveFoo = wrapExpensive(startFoo)

}

有什么建议，或者我应该考虑自己动手做吗？

Answer 1

我不是专家，但这种模式对我有用:

private var fooPromise : Promise<Foo>?

func doExpensiveFoo() -> Promise<Foo> {
    if let fooPromise = self.fooPromise, fooPromise.isPending {
        // return the pending promise
        return fooPromise
    }

    // reassign a newly created promise
    fooPromise = firstly { 
        // do your thing
        ...
    }

    return fooPromise!
  }

我喜欢这种模式的地方在于，该方法在内部处理挂起状态，并且如果在完成后调用，promise 会自动重新执行。这允许调用者不知道内部机制或 promise 的状态。显然，如果您需要调用者参与决策，则保留“force”标志方法。