             }
         }
     }
-    
-    init?(hour: Int, min:Int) {
+    public init?(hour: Int, min:Int) {
         if (hour >= 0 && hour < 24) && (min >= 0 && min < 60) {
             self.hour = hour
             self.min = min

            dayInt = dayInt % 7 + 7
        }
    }
    public init?(stringValue: String) {
        let lowerCase = stringValue.lowercaseString
        let rawValue: Int
        switch lowerCase {

    case abbr
}

public protocol DNTimeUnit: class {
    var interval: Interval { get set }
    func increase(by interval:Interval)
    func decrease(by interval:Interval)
    func increase()
    func decrease()
    func stringValue(forFormat format: TimeAndDayFormat) -> String
    init?(stringValue: StringValue)
    associatedtype TimeAndDayFormat
    associatedtype Interval
    associatedtype StringValue
}

public class AnyTimeUnit<Format, Interval, StringValue>: DNTimeUnit {
    private let _stringValue: (Format) -> String
    private let _increaseBy:(by: Interval) -> ()
    private let _decreaseBy:(by: Interval) -> ()
    private let _increase: () -> Void
    private let _decrease: () -> Void
    public var interval: Interval
    public init<Base: DNTimeUnit where Format == Base.TimeAndDayFormat, Interval == Base.Interval, StringValue == Base.StringValue>(_ base: Base) {
        _stringValue = base.stringValue
        _increaseBy = base.increase(by:)
        _decreaseBy = base.decrease(by:)
        _decrease = base.decrease
        _increase = base.increase
        interval = base.interval
    }
    public func stringValue<S: DNTimeUnit where S.TimeAndDayFormat == Format>(forFormat format: Format) -> String {
        return _stringValue(format)
    }
    public func decrease(by interval: Interval) {
        _decreaseBy(by: interval)
    }
    public func increase(by interval: Interval) {
        _increaseBy(by: interval)
    }
    public func decrease() {
        _decrease()
    }
    public func increase() {
        _increase()
    }
    public required init?(stringValue:String) {
        fatalError("Must use base init for type erasure AnyStringableTimeUnit")
    }
}


public class DNDay: DNTimeUnit {
    //Int/raw values match the Gregorian Calendar day of the week format
    public var interval = 1
    public var rawValue: Int {
        didSet {
            var returnValue = rawValue
            if returnValue > 7 {
                returnValue = returnValue % 7
                if returnValue == 0 {
                    returnValue = 7
                }
            } else if returnValue < 1 {
                returnValue = returnValue % 7 + 7
            }
            rawValue = returnValue
        }
    }
    public func stringValue(forFormat format: DNDayFormat) -> String {
        switch rawValue {
        case 1: return format == .full ? "Sunday" : "Sun"
        case 2: return format == .full ? "Monday" : "Mon"
        case 3: return format == .full ? "Tuesday" : "Tues"
        case 4: return format == .full ? "Wednesday" : "Wed"
        case 5: return format == .full ? "Thursday" : "Thurs"
        case 6: return format == .full ? "Friday" : "Fri"
        case 7: return format == .full ? "Saturday" : "Sat"
        default: return format == .full ? "Monday" : "Mon"
        }
    }
    enum DayError: ErrorType {
        case invalidString(String)
    }
    public func increase(by days:Int) {
        rawValue += days % 7
    }
    public func decrease(by days:Int) {
        rawValue -= days % 7
    }
    public func increase() {
        increase(by: interval)
    }
    public func decrease() {
        decrease(by: interval)
    }
    
    private func normalize(inout dayInt: Int) {
