 	/// - Returns: a `SignalMulti<State>`
 	public final func reduce<State>(initialState: State, context: Exec = .direct, reducer: @escaping (_ state: inout State, _ message: Value) throws -> State) -> SignalMulti<State> {
 		return SignalMulti<State>(processor: attach { (s, dw) in
-			return SignalReducer<Value, State>(signal: s, state: Result<State>.success(initialState), dw: &dw, context: context) { (state: inout Result<State>, message: Result<Value>) throws -> State in
+            return SignalReducer<Value, State>(signal: s, state: Result<State>.success(initialState), dw: &dw, context: context) { (state: inout Result<State>, message: Result<Value>) -> Result<State> in
 				switch (state, message) {
-				case (.success(var s), .success(let m)):
-					let emitState = try reducer(&s, m)
-					state = .success(s)
-					return emitState
-				case (.failure(let e), _): throw e
+                    state =  Result<State> { try reducer(&s, m) }
+                    return state
+                case (.failure, _):
+                    return state
 				case (_, .failure(let e)):
 					state = .failure(e)
-					throw e
+                    return state
 				}
 			}
 		})

				
				// Perform the update on the copy
				let previous = state
				_ = try? s.reducer(&state, r)
				
				// Apply the change to the authoritative version under the mutex
				s.sync {
					s.state = state


// Implementation of a processor that can output to multiple `Signal`s. Used by `continuous`, `continuous`, `playback`, `multicast`, `customActivation` and `preclosed`.
fileprivate final class SignalReducer<Value, State>: SignalProcessor<Value, State>, SignalBlockable {
    typealias Reducer = (_ state: inout Result<State>, _ message: Result<Value>) -> Result<State>
	let reducer: Reducer
	var state: Result<State>
	
