 extension ArrayVariable: RangeReplaceableCollectionType {
     public func replaceRange<C : CollectionType where C.Generator.Element == Generator.Element>(subRange: Range<Int>, with newElements: C) {
         value.replaceRange(subRange, with: newElements)
-        signal.send(.ReplaceRange(subRange, with: Array<Element>(newElements)))
+        _futureChanges?.send(.ReplaceRange(subRange, with: Array<Element>(newElements)))
     }
 
     // These have default implementations in terms of replaceRange, but doing them by hand makes for better change reports.

        return value.count
    }

    public var observableCount: Observable<Int> {
        var count = self.count
        return Observable(
            getter: { self.count },
            futureChanges: signal.map { 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
                }
                return SimpleChange(oldValue: oldCount, newValue: count)
            })
    }

    private weak var _futureValues: Signal<[Element]>? = nil
    public var futureValues: Source<[Element]> {
        if let signal = _futureValues {
            return signal.source

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