enums - 您什么时候会优先使用具有关联值的枚举而不是静态工厂？

Question

在 Swift 中，您可以定义一个枚举并通过关联值为其赋予一个属性，例如:

protocol SizeEnum {
    var length : Double? { get } // Length should be >= 0 - has to be an Optional for errors
}

enum SizesEnum : SizeEnum {
    case Short(length : Double) // 0 <= length <= maxShort
    case Long(length : Double) // length > maxShort
    private static let maxShort =  1.0
    var length : Double? {
    get {
        switch self {
        case let .Short(length):
            if length >= 0 && length <= SizesEnum.maxShort { // Need to error check every access
                return length
            }
        case let .Long(length):
            if length > SizesEnum.maxShort { // Need to error check every access
                return length
            }
        }
        return nil // There was an error
    }
    }
}

SizesEnum.Short(length: 0.5).length // [Some 0.5]
SizesEnum.Short(length: 2).length // nil
SizesEnum.Long(length: 2).length // [Some 2.0]
SizesEnum.Long(length: -1).length // nil

但这并不理想，因为:

1. 长度参数的错误检查只能在访问时进行，不能拦截初始化
2. 长度参数出奇地冗长

另一种对我来说似乎更好的选择是使用静态工厂，例如:

protocol SizeStruct {
    var length : Double { get } // Length should be >= 0 - is *not* an Optional
}

struct SizesStruct : SizeStruct {
    static func Short(length : Double) -> SizeStruct? {
        if length >= 0 && length <= maxShort { // Check at creation only
            return SizesStruct(length)
        }
        return nil
    }
    static func Long(length : Double) -> SizeStruct? {
        if length > maxShort { // Check at creation only
            return SizesStruct(length)
        }
        return nil
    }
    let length : Double
    private static let maxShort = 1.0
    private init(_ length : Double) {
        self.length = length
    }
}

SizesStruct.Short(0.5)?.length // [Some 0.5]
SizesStruct.Short(2)?.length // nil
SizesStruct.Long(2)?.length // [Some 2.0]
SizesStruct.Long(-1)?.length // nil

考虑到静态工厂解决方案更简洁，我什么时候真正使用带值的枚举？我错过了什么吗？有 killer 用例吗？

回应 drawag

对于 Optional 其他语言，例如Java 和 Scala，你使用工厂，这里介绍 Java 版本:http://docs.oracle.com/javase/8/docs/api/java/util/Optional.html工厂是 of 方法。

在 Swift 中你会做这样的事情:

class Opt { // Note only Some stores the value, not None
    //class let None = Opt() - class variables not supported in beta 4!
    class Some<T> : Opt {
        let value : T
        init(_ value : T) {
            self.value = value
        }
    }
    private init() {} // Stop any other ways of making an Opt
}

Opt.Some(1).value // 1

这可能是 enum 的最佳示例，因为不需要错误检查，但即使如此，出厂版本也具有竞争力。 Optional 示例非常简单，您甚至不需要工厂，您只需直接创建 Some。请注意 None 如何不使用任何存储空间。

条形码示例显示工厂技术有多好；实际上，并非所有 4 个 Int 的集合都是有效的 UPCA，而且并非所有 String 都是有效的 QR 码，因此您需要错误检查，这对 来说很痛苦枚举s。这是出厂版本:

class Barcode { // Note seperate storage for each case
    class UPCABarcode : Barcode {
        let type : Int, l : Int, r : Int, check : Int
        private init(type : Int, l : Int, r : Int, check : Int) {
            (self.type, self.l, self.r, self.check) = (type, l, r, check)
        }
    }
    class func UPCA(#type : Int, l : Int, r : Int, check : Int) -> UPCABarcode? {
        if ok(type: type, l: l, r: r, check: check) {
            return UPCABarcode(type: type, l: l, r: r, check: check)
        }
        return nil
    }
    class func QRCode(#s : String) -> Barcode? { // Have not expanded this case; use same pattern as UPCA
        return Barcode()
    }
    private init() {} // Prevent any other types of Barcode
    class func ok(#type : Int, l : Int, r : Int, check : Int) -> Bool {
        return true // In practice has to check supported type, range of L and R, and if check digit is correct
    }
}

Barcode.UPCA(type: 0, l: 1, r: 2, check: 3)

如果您使用 Barcode 的 enum 版本，那么每次您使用 Barcode 时，您都必须检查其有效性，因为没有什么可停止无效的条形码。而工厂版本在创建时进行检查。注意 Barcode 没有存储而 UPCA 有自定义存储。我没有编写 QRCode 代码，因为它使用与 UPCA 相同的设计模式。

我的印象是，enum 版本在教程中看起来很棒，但由于错误处理，很快就会在实践中变得痛苦。

Answer 1

我相信最大的 killer 级用例是Optional。它内置于语言中，但可选的只是一个枚举:

enum Optional<T> {
    case None
    case Some(T)
}

在这种情况下，像 value 这样的成员变量没有意义，因为在 None 的情况下，实际上没有值。

此外，就在 Swift tour 之外:

enum Barcode {
    case UPCA(Int, Int, Int, Int)
    case QRCode(String)
}

如果使用结构体，将会有很多浪费的成员变量和一个令人困惑的接口(interface)来为此类数据建模。

如果每种情况都使用相同的类型，我认为为枚举使用关联值是没有意义的。在那种情况下，成员变量更干净。关联值的重点是更准确地对某些类型的数据建模。最有用的情况是一个类型的不同实例可以有不同的关联数据。这可能可以通过子类来完成，但是这样就需要向下转换才能访问更具体的变量，并且声明会更加冗长。枚举是表示此类数据的简洁方式。

另一个例子可能是网络请求:

struct NetRequest {
    enum Method {
        case GET
        case POST(String)
    }

    var URL: String
    var method: Method
}

var getRequest = NetRequest(URL: "http://drewag.me", method: .GET)
var postRequest = NetRequest(URL: "http://drewag.me", method: .POST("{\"username\": \"drewag\"}"))

当我想到“枚举”时，我根本不会想到“工厂”。通常工厂用于更大更复杂的类结构。枚举应该是非常小的数据片段，几乎没有逻辑。