   }
 }
 
-public enum NewChordAccidentType: ChordDescription {
-  case natural // no accident
-  case flat // halfstep down
-  case sharp // halfstep up
-
-  public var notation: String {
-    switch self {
-    case .natural: return ""
-    case .flat: return "♭"
-    case .sharp: return "♯"
-    }
-  }
-
-  public var description: String {
-    switch self {
-    case .natural: return "Natural"
-    case .flat: return "Flat"
-    case .sharp: return "Sharp"
-    }
-  }
-
-  public static var all: [NewChordAccidentType] {
-    return [.natural, .flat, .sharp]
-  }
-}
-
-public enum NewChordExtensionType: Int, ChordDescription {
-  case ninth = 9
-  case eleventh = 11
-  case thirteenth = 13
-
-  public var notation: String {
-    switch self {
-    case .ninth: return "9"
-    case .eleventh: return "11"
-    case .thirteenth: return "13"
-    }
-  }
-
-  public var description: String {
-    switch self {
-    case .ninth: return "9th"
-    case .eleventh: return "11th"
-    case .thirteenth: return "13th"
-    }
-  }
-
-  public static var all: [NewChordExtensionType] {
-    return [.ninth, .eleventh, .thirteenth]
-  }
-}
-
-public struct NewChordExtension: ChordDescription {
-  public var type: NewChordExtensionType
-  public var accident: NewChordAccidentType
+public struct NewChordExtensionType: ChordPart {
+
+  public enum Accident {
+    case natural
+    case flat
+    case sharp
+
+    public static var all: [Accident] {
+      return [.natural, .flat, .sharp]
+    }
+  }
+
+  public enum ExtensionType: Int {
+    case ninth = 9
+    case eleventh = 11
+    case thirteenth = 13
+
+    public static var all: [ExtensionType] {
+      return [.ninth, .eleventh, .thirteenth]
+    }
+  }
+
+  public var type: ExtensionType
+  public var accident: Accident
   public var isMajor: Bool
   public var isAdded: Bool
 
-  public init(type: NewChordExtensionType, accident: NewChordAccidentType = .natural, isMajor: Bool = false, isAdded: Bool = false) {
+  public init(type: ExtensionType, accident: Accident = .natural) {
+    self.type = type
+    self.accident = accident
+    self.isMajor = false
+    self.isAdded = false
+  }
+
+  internal init(type: ExtensionType, accident: Accident = .natural, isMajor: Bool = false, isAdded: Bool = false) {
     self.type = type
     self.accident = accident
     self.isMajor = isMajor
     self.isAdded = isAdded
   }
 
-  public var notation: String {
+  public var interval: Interval {
+    var typeInterval = 0
+    switch type {
+    case .ninth: typeInterval = (.M2 * 2).halfstep
+    case .eleventh: typeInterval = (.P4 * 2).halfstep
+    case .thirteenth: typeInterval = (.M6 * 2).halfstep
+    }
+
+    var accidentInterval = 0
+    switch accident {
+    case .natural: accidentInterval = 0
+    case .flat: accidentInterval = -1
+    case .sharp: accidentInterval = 1
+    }
+
+    return Interval(halfstep: typeInterval + accidentInterval)
+  }
+
+  public var notation: String {
+    var typeNotation = ""
+    switch type {
+    case .ninth: typeNotation = "9"
+    case .eleventh: typeNotation = "11"
+    case .thirteenth: typeNotation = "13"
+    }
+
+    var accidentNotation = ""
+    switch accident {
+    case .natural: accidentNotation = ""
+    case .flat: accidentNotation = "♭"
+    case .sharp: accidentNotation = "♯"
+    }
+
     if isMajor {
-      return "maj\(accident.notation)\(type.notation)"
+      return "maj\(accidentNotation)\(typeNotation)"
     } else if isAdded {
-      return "add\(accident.notation)\(type.notation)"
+      return "add\(accidentNotation)\(typeNotation)"
     } else {
-      return "\(accident.notation)\(type.notation)"
-    }
-  }
-
-  public var description: String {
-    return "\(isAdded ? "Added " : "")\(accident) \(type)"
-  }
-
-  public static var all: [NewChordExtension] {
-    var all = [NewChordExtension]()
-    for type in NewChordExtensionType.all {
-      for accident in NewChordAccidentType.all {
-        all.append(NewChordExtension(type: type, accident: accident))
+      return "\(accidentNotation)\(typeNotation)"
+    }
+  }
+
+  public var description: String {
+    var typeDescription = ""
+    switch type {
+    case .ninth: typeDescription = "9th"
+    case .eleventh: typeDescription = "11th"
+    case .thirteenth: typeDescription = "13th"
+    }
+
+    var accidentDescription = ""
+    switch accident {
+    case .natural: accidentDescription = "Natural"
+    case .flat: accidentDescription = "Flat"
+    case .sharp: accidentDescription = "Sharp"
+    }
+
+    return "\(isAdded ? "Added " : "")\(accidentDescription) \(typeDescription)"
+  }
+
+  public static var all: [NewChordExtensionType] {
+    var all = [NewChordExtensionType]()
+    for type in ExtensionType.all {
+      for accident in Accident.all {
+        all.append(NewChordExtensionType(type: type, accident: accident))
       }
     }
     return all

        return elements.map {[$0]}
      }

      var comb = [[NewChordExtension]]()
      for (index, element) in elements.enumerated() {
        var reducedElements = elements
        reducedElements.removeFirst(index + 1)


  public var description: String {
    return "\(key) \(type)"
  }

  public static var all: [NewChord] {
