   }
   
   /// The underlying array.
-  public var array: [ElementType]
+  public var array: [ElementType] {
+    get {
+      if let workingBatchArray = workingBatchArray {
+        return workingBatchArray
+      } else {
+        return replayBuffer!.last!.sequence
+      }
+    }
+    set {
+      next(ObservableArrayEvent(sequence: newValue, operation: ObservableArrayOperation.Reset(array: newValue)))
+    }
+  }
   
   /// Creates a new array with the given initial value.
   public init(_ array: [ElementType]) {
-    self.array = array
-    
-    var capturedSink: Sink! = nil
-    super.init(replayLength: 1, lifecycle: .Normal) { sink in
-      capturedSink = sink
-      return nil
-    }
-    
-    self.capturedSink = capturedSink
-    self.capturedSink(ObservableArrayEvent(sequence: array, operation: ObservableArrayOperation.Reset(array: array)))
+    super.init(replayLength: 1)
+    next(ObservableArrayEvent(sequence: array, operation: ObservableArrayOperation.Reset(array: array)))
   }
   
   /// Performs batch updates on the array.

/// A type that can be used to encapsulate an array and observe its (incremental) changes.
public final class ObservableArray<ElementType>: EventProducer<ObservableArrayEvent<Array<ElementType>>>, ObservableArrayType {
  
  /// The underlying sink to dispatch events to.
  private var capturedSink: Sink! = nil
  
  /// Batched array operations.
  private var batchedOperations: [ObservableArrayOperation<ElementType>]! = nil
  
  /// Returns `true` if batch update is in progress at the moment.
  private var isBatchUpdateInProgress: Bool {

  ///   }
  public func performBatchUpdates(@noescape update: ObservableArray<ElementType> -> ()) {
    batchedOperations = []
    workingBatchArray = array
    update(self)
    let operationToSend = ObservableArrayOperation.Batch(batchedOperations!)
    let arrayToSend = workingBatchArray!
    workingBatchArray = nil
    batchedOperations = nil
    next(ObservableArrayEvent(sequence: arrayToSend, operation: operationToSend))
  }
  
  public func applyOperation(operation: ObservableArrayOperation<ElementType>) {
    if isBatchUpdateInProgress {
      ObservableArray.performOperation(operation, onArray: &workingBatchArray!)
      batchedOperations!.append(operation)
    } else {
      var arrayCopy = array
      ObservableArray.performOperation(operation, onArray: &arrayCopy)
      next(ObservableArrayEvent(sequence: arrayCopy, operation: operation))
    }
  }
  
  private static func performOperation(operation: ObservableArrayOperation<ElementType>, inout onArray array: [ElementType]) {
    switch operation {
    case .Reset(let newArray):
      array = newArray
