         }
         set {
             value[index] = newValue
-            signal.send(.ReplaceAt(index, with: newValue))
+            _futureChanges?.send(.ReplaceAt(index, with: newValue))
         }
     }
 

        }
        set {
            value[bounds] = newValue
            signal.send(.ReplaceRange(bounds, with: Array<Element>(newValue)))
        }
    }
}

        return value.count
    }

    private var futureCounts: Signal<SimpleChange<Int>> {
        if let futureCounts = _futureCounts {
            return futureCounts
        }
        else {
            var connection: Connection? = nil
            let signal = Signal<SimpleChange<Int>>(
                didConnectFirstSink: { signal in
                    var count = self.count
                    connection = self.futureChanges.connect { change in
                        let oldCount = count
                        switch change {
                        case .Insert(_, at: _):
                            count += 1
                        case .RemoveAt(_):
                            count -= 1
                        case .ReplaceAt(_, with: _):
                            break // Count doesn't change.
                        case .ReplaceRange(let range, with: let elements):
                            count += elements.count - range.count
                        case .ReplaceAll(let elements):
                            count = elements.count
                        }
                        signal.send(SimpleChange(oldValue: oldCount, newValue: count))
                    }
                },
                didDisconnectLastSink: { signal in
                    connection?.disconnect()
                    connection = nil
            })
            _futureCounts = signal
            return signal
        }
    }
    public var observableCount: Observable<Int> {
        return Observable(getter: { self.count }, futureChanges: self.futureCounts)
    }

    public var futureValues: Source<[Element]> {
        if let signal = _futureValues {
            return signal.source
