 				
 				// Perform the update on the copy
 				let previous = state
-				let result = Result<State> { try s.reducer(&state, r) }
-				
+                let result = s.reducer(&state, r)
+
 				// Apply the change to the authoritative version under the mutex
 				var outputs: OutputsArray = []
 				s.sync {


// 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>) throws -> State
	let reducer: Reducer
	var state: Result<State>
	

	/// - 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>) -> Result<State> in
				switch (state, message) {
                    state =  Result<State> { try reducer(&s, m) }
                    return state
                case (.failure, _):
                    return state
				case (_, .failure(let e)):
					state = .failure(e)
                    return state
				}
			}
		})
