 			disposable += self.observe { event in
 				switch event {
 				case let .Next(value):
-					state.modify { (var st) in
-						st.latestValue = value
-						return st
+					state.modify { st in
+						var mutableSt = st
+						mutableSt.latestValue = value
+						return mutableSt
 					}
 				case let .Failed(error):
 					observer.sendFailed(error)
 				case .Completed:
-					let oldState = state.modify { (var st) in
-						st.signalCompleted = true
-						return st
+					let oldState = state.modify { st in
+						var mutableSt = st
+						mutableSt.signalCompleted = true
+						return mutableSt
 					}
 					
 					if oldState.samplerCompleted {

				case let .Failed(error):
					observer.sendFailed(error)
				case .Completed:
					let original = state.modify { (var state) in
						state.outerSignalComplete = true
						return state
					}

					if original.innerSignalComplete {

							case .Interrupted:
								// If interruption occurred as a result of a new producer
								// arriving, we don't want to notify our observer.
								let original = state.modify { state in
									var mutableState = state

									if !mutableState.replacingInnerSignal {
										mutableState.innerSignalComplete = true
									}

									return mutableState
								}

								if !original.replacingInnerSignal && original.outerSignalComplete {
