 			disposable += self.observe { event in
 				if case let .Next(value) = event {
 					var scheduleDate: NSDate!
-					state.modify { (var state) in
-						state.pendingValue = value
-
-						let proposedScheduleDate = state.previousDate?.dateByAddingTimeInterval(interval) ?? scheduler.currentDate
+					state.modify { state in
+						var mutableState = state
+						mutableState.pendingValue = value
+
+						let proposedScheduleDate = mutableState.previousDate?.dateByAddingTimeInterval(interval) ?? scheduler.currentDate
 						scheduleDate = proposedScheduleDate.laterDate(scheduler.currentDate)
 
-						return state
+						return mutableState
 					}
 
 					schedulerDisposable.innerDisposable = scheduler.scheduleAfter(scheduleDate) {
-						let previousState = state.modify { (var state) in
-							if state.pendingValue != nil {
-								state.pendingValue = nil
-								state.previousDate = scheduleDate
+						let previousState = state.modify { state in
+							var mutableState = state
+
+							if mutableState.pendingValue != nil {
+								mutableState.pendingValue = nil
+								mutableState.previousDate = scheduleDate
 							}
 
-							return state
+							return mutableState
 						}
 						
 						if let pendingValue = previousState.pendingValue {

								}

							case .Completed:
								let original = state.modify { (var state) in
									state.innerSignalComplete = true
									return state
								}

								if original.outerSignalComplete {

			disposable += self.observe { event in
				switch event {
				case let .Next(value):
					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 { st in
						var mutableSt = st
						mutableSt.signalCompleted = true
						return mutableSt
					}
					
					if oldState.samplerCompleted {
