什么'；如果一个承诺书已经在运行，那么返回一个未决承诺书的最佳Swift模式是什么？

我有一些昂贵的承诺，在不同的地方都会收到。理想情况下，我只想将现有的机上承诺（使用可选的强制力）连锁反应，因此我发现自己在做这样的事情：

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 {
       // ...
    }
  }
}

类昂贵{
承诺：承诺？
我保证：保证？
func doExpensiveFoo（force:bool=false）->Promise{
如果let existing=fooPromise where existing.pending | |（existing.fufilled&&！force）{
//返回现有的承诺
返回现有的
}
//开始一个新的Foo
先返回{
// ...
}
}
func-doExpensiveBar（force:bool=false）->Promise{
如果let existing=barPromise where existing.pending | |（existing.fufilled&&！force）{
//返回现有的承诺
返回现有的
}
//开一家新酒吧
先返回{
// ...
}
}
}

但这感觉像是一个相当多的锅炉板（每个承诺都有一个局部变量，每个函数开头都有一个块），所以我想知道是否有人见过一个很好的模式来抽象变量和包装器

借用Python的一个术语，我正在寻找一个能够隐藏所有这些内容的装饰器。比如：

class Expensive {

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

  public doExpensiveFoo = wrapExpensive(startFoo)

}

类昂贵{
private func startFoo（）->Promise{
先返回{
//..
}
}
public doExpensiveFoo=wrapExpensive（startFoo）
}

---

有什么建议吗，或者我应该看看自己的滚动吗？

在您的示例中，我没有看到Foo和Bar的任何共同基础。但即使他们有一个Swift，仍然不支持泛型类型参数的协方差。首先，您需要为这两种类型创建一个通用协议。也许这有助于你走上正轨：

---

我不是专家，但这种模式对我有效：

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!
  }

承诺：承诺？
func doExpensiveFoo（）->Promise{
如果let fooPromise=self.fooPromise，则fooPromise.isPending{
//归还未兑现的承诺
回报承诺
}
//重新分配新创建的承诺
fooPromise=首先{
//做你的事
...
}
回报你的承诺！
}

我喜欢这种模式的地方在于，该方法在内部处理挂起状态，如果在完成后调用，承诺将自动重新执行。这允许调用方不知道内部机制或承诺的状态。显然，如果您需要调用方参与决策，那么请使用“force”标志方法