 //
 
 public struct Diff<T> {
-    let results: [DiffStep<T>]
-    var insertions: [DiffStep<T>] {
+    public let results: [DiffStep<T>]
+    public var insertions: [DiffStep<T>] {
         return results.filter({ $0.isInsertion }).sort { $0.idx < $1.idx }
     }
-    var deletions: [DiffStep<T>] {
+    public var deletions: [DiffStep<T>] {
         return results.filter({ !$0.isInsertion }).sort { $0.idx > $1.idx }
     }
-    func reversed() -> Diff<T> {
+    public func reversed() -> Diff<T> {
         let reversedResults = self.results.reverse().map { (result: DiffStep<T>) -> DiffStep<T> in
             switch result {
             case .Insert(let i, let j):

            return "-\(j)@\(i)"
        }
    }
    var idx: Int {
        switch(self) {
        case .Insert(let i, _):
            return i

    }
}

public func +<T> (left: Diff<T>, right: DiffStep<T>) -> Diff<T> {
    return Diff<T>(results: left.results + [right])
}

