快速语言中是否存在任何用于通过单个队列中的闭包级联函数调用的机制？

Question

我有一个任务，要相对于彼此以一定顺序同步调用函数。

我意识到我的功能，但是由于某种原因，当我检查它时，发现一个异常。 假设如果您列出了要解决哪些权限的呼叫列表，而当您停止解决第一个请求约1分钟时，其他权限将通过

class RunFuncs {
    typealias TypeFuncCall<T> = ((_ completed: @escaping (T) -> Void) -> Void)
    static func cascad<T>(dispatchQueue queue: DispatchQueue,
                          callFuncs funcs: [TypeFuncCall<T>], 
                          indexFuncRun index: Int = 0,
                          completedAll: @escaping (([T]) -> Void)) {
        queue.async {
            guard (funcs.count > index) else {
                completedAll([T]())
                return
            }
            let callOne = funcs[index]
            let indexNext = (index + 1)
            callOne() { [completedAll, funcs, indexNext] (resultOne) in
                RunFuncs.cascad(dispatchQueue: queue,
                                callFuncs: funcs,
                                indexFuncRun: indexNext,
                                completedAll: { (resultOther) in
                    var resultAll = resultOther
                    resultAll.insert(resultOne, at: 0)
                    completedAll(resultAll)
                })
            }
        }
    }
}