orderedDict.swift

public struct OrderedDictionary<Tk: Hashable, Tv> : MutableCollectionType {
  var keys: [Tk] = []
  var values: [Tk:Tv] = [:]
  
  public typealias Index = Int
  
  public var count: Int {
    return self.keys.count
  }
  
  public var startIndex: Int {
    return self.keys.startIndex
  }
  
  public var endIndex: Int {
    return self.keys.endIndex
  }
    
  public func generate() -> LazyMapGenerator<IndexingGenerator<Array<Tk>>, (Tk, Tv)> {
    return keys.lazy.map { k in (k, self.values[k]!) }.generate()
  }
  
  public subscript(index: Int) -> (Tk, Tv) {
    get {
      let key = self.keys[index]
      return (key, self.values[key]!)
    }
    set {
      let key = self.keys[index]
      self.values.removeValueForKey(key)
      self.keys[index] = newValue.0
      self.values[newValue.0] = newValue.1
    }
  }

  public subscript(key: Tk) -> Tv? {
      get {
          return self.values[key]
      }
      set(newValue) {
          if newValue == nil {
              self.values.removeValueForKey(key)
              self.keys = self.keys.filter {$0 != key}
          }
          
          let oldValue = self.values.updateValue(newValue!, forKey: key)
          if oldValue == nil {
              self.keys.append(key)
          }
      }
  }
  
  public var description: String {
      var result = "{\n"
      for i in 0..<self.count {
          result += "[\(i)]: \(self.keys[i]) => \(self[i])\n"
      }
      result += "}"
      return result
  }
}