         set {
             value[index] = newValue
             if index == value.count {
-                updates.send([Update(.insert, [index])])
+                updates.send([ArrayUpdate(.insert, [index])])
             } else {
-                updates.send([Update(.replace, [index])])
+                updates.send([ArrayUpdate(.replace, [index])])
             }
         }
     }

    }
}

public final class ObservableArray<T: Equatable>: ObservableValueHolder<[T]>, Collection, MutableCollection, CustomStringConvertible, CustomDebugStringConvertible, ExpressibleByArrayLiteral, RangeReplaceableCollection {

    public typealias Element = T

    public struct Update {
        public enum Event {
            case insert
            case delete
            case replace
        }

        public let event: Event
        public let indexes: [Index]

        public init(_ type: Event,
                    _ indexes: [Index]) {
            self.event = type
            self.indexes = indexes
        }
    }

    public let updates = Signal<[Update]>()

    public init() {
        super.init([])

        set {
            value[bounds] = newValue
            let first = bounds.lowerBound
            updates.send([ArrayUpdate(.insert, Array(first..<first + newValue.count)),
                          ArrayUpdate(.delete, Array(bounds.lowerBound..<bounds.upperBound))])
        }
    }

    // Insertions
    public func insert(_ newElement: T, at i: Index) {
        value.insert(newElement, at: i)
        updates.send([ArrayUpdate(.insert, [i])])
    }

    public func insert<C>(contentsOf newElements: C, at i: Int) where C : Collection, T == C.Element {
