Swift: Compsed Types

final class Box<T> {
    let value: T
    
    init(_ value: T) {
        self.value = value
    }
}

protocol DataType : Printable {
}

protocol PrimitiveType : DataType {
}

enum UndefinedType : String, PrimitiveType {
    case Undefined = "Undefined"
    case Null = "Uninitialized"
    
    var description : String {
        return rawValue
    }
    
    static func fromState(state: String) -> UndefinedType {
        return UndefinedType(rawValue: state)!
    }
}

enum OnOffType : String, PrimitiveType {
    case On = "ON"
    case Off = "OFF"
    
    var description : String {
        return rawValue
    }
}

enum PercentType : PrimitiveType {
    case Zero
    case Hundred
    case Value(Int)
    
    var value : Int {
        switch self {
        case .Zero:
            return 0
        case .Hundred:
            return 100
        case .Value(let value):
            return value
        }
    }
    
    var description : String {
        return String(value)
    }
}

enum ComposedType<P : PrimitiveType, T : DataType> : DataType {
    case Left(Box<P>)
    case Right(Box<T>)
    
    var description : String {
        switch self {
        case .Left(let box):
            return box.value.description
        case .Right(let box):
            return box.value.description
        }
    }
    
    init(_ value: P) {
        self = .Left(Box(value))
    }
    
    init(_ value: T) {
        self = .Right(Box(value))
    }
}

var state : ComposedType<OnOffType, ComposedType<UndefinedType, PercentType>>

state = ComposedType(OnOffType.On)
state.description // => "On"

state = ComposedType(ComposedType(PercentType.Value(37)))
state.description // => "37"