   return combine(queue: queue, deferreds: deferreds)
 }
 
+/// Combine a Sequence of `Deferred`s into a new `Deferred` whose value is an array.
+/// The combined `Deferred` will become determined after every input `Deferred` is determined.
+/// The combined `Deferred` will use a new queue at the current QoS.
+///
+/// If any of the elements resolves to an error, the combined `Deferred` will contain that error.
+///
+/// - parameter deferreds: a `Sequence` of `Deferred`
+/// - returns: a new `Deferred`
+
 public func combine<Value, S: Sequence>(_ deferreds: S) -> Deferred<[Value]>
   where S.Iterator.Element == Deferred<Value>
 {
   return combine(qos: .current, deferreds: deferreds)
 }
+
+/// Combine a Sequence of `Deferred`s into a new `Deferred` whose value is an array.
+/// The combined `Deferred` will become determined after every input `Deferred` is determined.
+/// The combined `Deferred` will use the supplied queue.
+///
+/// If any of the elements resolves to an error, the combined `Deferred` will contain that error.
+///
+/// - parameter queue: the queue onto which the `combine` operation and its notifications will occur
+/// - parameter deferreds: a `Sequence` of `Deferred`
+/// - returns: a new `Deferred`
 
 public func combine<Value, S: Sequence>(queue: DispatchQueue,
                                         deferreds: S) -> Deferred<[Value]>

  return combine(queue: queue, deferreds: deferreds)
}

public func combine<Value, C: Collection>(_ deferreds: C) -> Deferred<[Value]>
where C.Iterator.Element == Deferred<Value>
{
  return combine(qos: .current, deferreds: deferreds)
}

public func combine<Value, C: Collection>(queue: DispatchQueue,
                                          deferreds: C) -> Deferred<[Value]>

  return reduce(queue: queue, deferreds: deferreds, initial: initial, combine: combine)
}

/// Returns the result of repeatedly calling `combine` with an
/// accumulated value initialized to `initial` and each element of
/// `deferreds`, in turn. That is, return a deferred version of
/// `combine(combine(...combine(combine(initial, deferreds[0].value),
/// deferreds[1].value),...deferreds[count-2].value), deferreds[count-1].value)`.
/// (Never mind that you can't index a Sequence.)
///
/// If any of the elements resolves to an error, the resulting `Deferred` will contain that error.
/// If the reducing function throws an error, the resulting `Deferred` will contain that error.
/// The combined `Deferred` will use a new queue at the current QoS.
///
/// - parameter deferreds: a `Sequence` of `Deferred`
/// - parameter initial: a value to use as the initial accumulating value
/// - parameter combine: a reducing function
/// - returns: a new `Deferred`
/// - parameter accumulated: the accumulated value up to this element of the `Collection`
/// - parameter element: a new element to be accumulated

public func reduce<S: Sequence, T, U>(_ deferreds: S, initial: U,
                                      combine: @escaping (_ accumulated: U, _ element: T) throws -> U) -> Deferred<U>
  where S.Iterator.Element == Deferred<T>
{
  return reduce(qos: .current, deferreds: deferreds, initial: initial, combine: combine)
}

/// Returns the result of repeatedly calling `combine` with an
/// accumulated value initialized to `initial` and each element of
/// `deferreds`, in turn. That is, return a deferred version of
/// `combine(combine(...combine(combine(initial, deferreds[0].value),
/// deferreds[1].value),...deferreds[count-2].value), deferreds[count-1].value)`.
/// (Never mind that you can't index a Sequence.)
///
/// If any of the elements resolves to an error, the resulting `Deferred` will contain that error.
/// If the reducing function throws an error, the resulting `Deferred` will contain that error.
/// The combined `Deferred` will use the supplied queue.
///
/// - parameter queue: the queue onto which the `reduce` operation and its notifications will occur
/// - parameter deferreds: a `Sequence` of `Deferred`
/// - parameter initial: a value to use as the initial accumulating value
/// - parameter combine: a reducing function
/// - returns: a new `Deferred`
/// - parameter accumulated: the accumulated value up to this element of the `Collection`
/// - parameter element: a new element to be accumulated

public func reduce<S: Sequence, T, U>(queue: DispatchQueue,
                                      deferreds: S, initial: U,
