     {
         return intervalQualityKinds(withIntervalClass: intervalClass) ?? []
     }
-    
-    
 }
 
 /**

        }
    }
    
    /// Seventh interval family.
    public class Seventh: EnumFamily, ImperfectIntervalQualityType {
        
        /// diminished Seventh interval.
        public static let diminished: EnumKind = .diminishedSeventh
        
        /// minor Seventh interval.
        public static let minor: EnumKind = .minorSeventh
        
        /// major Seventh interval.
        public static let major: EnumKind = .majorSeventh
        
        /// augmented Seventh interal.
        public static let augmented: EnumKind = .augmentedSeventh
        
        public override class var members: [EnumKind] { return imperfectMembers }
        
        // DEFAULT Impefect implementation
        public override class func kind(forPitchSpellingDyad pitchSpellingDyad: PitchSpellingDyad)
            -> EnumKind
        {
            // exception if lower is B or E
            let lowerDirection = pitchSpellingDyad.lower.coarse.direction.rawValue
            let higherDirection = pitchSpellingDyad.higher.coarse.direction.rawValue
            var difference: Float {
                var result = (higherDirection - lowerDirection)
                if [.b, .e].contains(pitchSpellingDyad.lower.letterName) { result -= 1 }
                return result
            }
            switch difference {
            case -2: return diminished
            case -1: return minor
            case +0: return major
            case +1: return augmented
            default: fatalError("Such an interval couldn't possibly exist")
            }
        }
    }
    
    public class var members: [EnumKind] {
        print("members container")
        return []
    }
    
    public class var subFamilies: [EnumFamily.Type] {
        print("subfamilies container")
        return [
            Unison.self,
            Second.self,

        
        /// augmented Second interval.
        public static let augmented: EnumKind = .augmentedSecond
        
        public override class var members: [EnumKind] { return imperfectMembers }
        
        // DEFAULT Impefect implementation
        public override class func kind(forPitchSpellingDyad pitchSpellingDyad: PitchSpellingDyad)
            -> EnumKind
        {
            let difference = directionDifference(fromPitchSpellingDyad: pitchSpellingDyad)
            switch difference {
            case -2: return diminished
            case -1: return minor
            case +0: return major
            case +1: return augmented
            default: fatalError("Such an interval couldn't possibly exist")
            }
        }
        
        static func adjustDifference(difference: Float,
            forLowerPitchSpelling pitchSpelling: PitchSpelling
        ) -> Float
        {
            return [.b, .e].contains(pitchSpelling.letterName) ? difference - 1 : difference
        }
    }
    
    /// Third interval family.
    public class Third: EnumFamily, ImperfectIntervalQualityType {
        
        /// diminished Third interval.
        public static let diminished: EnumKind = .diminishedThird
        
        /// minor Third interval.
        public static let minor: EnumKind = .minorThird
        
        /// major Third interval.
        public static let major: EnumKind = .majorThird
        
        /// augmented Third interval.
        public static let augmented: EnumKind = .augmentedThird
        
        public override class var members: [EnumKind] { return imperfectMembers }
        
