 /// - parameter accumulated: the accumulated value up to this element of the `Collection`
 /// - parameter element: a new element to be accumulated
 
-public func reduce<C: Collection, T, U>(queue: DispatchQueue,
-                                        deferreds: C, initial: U,
-                                        combine: @escaping (_ accumulated: U, _ element: T) throws -> U) -> Deferred<U>
-  where C.Element == Deferred<T>
-{
-  let reduced = deferreds.reduce(Deferred(queue: queue, value: initial)) {
+public func reduce<C: Collection, T, F, U>(queue: DispatchQueue,
+                                           deferreds: C, initial: U,
+                                           combine: @escaping (_ accumulated: U, _ element: T) -> U) -> Deferred<U, F>
+  where C.Element == Deferred<T, F>
+{
+  let reduced = deferreds.reduce(Deferred<U, F>(queue: queue, value: initial)) {
     (accumulator, deferred) in
     accumulator.flatMap {
-      u in deferred.map(queue: queue) { t in try combine(u,t) }
+      u in deferred.map(queue: queue) { t in combine(u,t) }
     }
   }
 

/// - parameter accumulated: the accumulated value up to this element of the `Collection`
/// - parameter element: a new element to be accumulated

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

/// - 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, F, U>(_ deferreds: S, initial: U,
                                         combine: @escaping (_ accumulated: U, _ element: T) -> U) -> Deferred<U, F>
  where S.Element == Deferred<T, F>
{
  return reduce(qos: .current, deferreds: deferreds, initial: initial, combine: combine)
}
