我可以将一个枚举限制为另一个枚举的某些情况吗？

Question

假设我有一家面包店和一份原料清单：

enum Ingredient {
    case flower     = 1
    case sugar      = 2
    case yeast      = 3
    case eggs       = 4
    case milk       = 5
    case almonds    = 6
    case chocolate  = 7
    case salt       = 8
}

一个案例的rawValue代表库存编号。

然后我有两个食谱：

巧克力蛋糕：

• 500g花
• 300克糖
• 3 个鸡蛋
• 200毫升牛奶
• 200克巧克力

杏仁蛋糕：

• 300克花
• 200克糖
• 20g酵母
• 200克杏仁
• 5 个鸡蛋
• 2g 盐

现在我定义一个函数

func bake(with ingredients: [Ingredient]) -> Cake

我当然信任我的员工，但我仍然想确保他们只使用正确的原料来烘烤蛋糕。 ????

我可以通过像这样定义两个单独的枚举来做到这一点：

enum ChocolateCakeIngredient {
    case flower
    case sugar
    case eggs
    case milk
    case chocolate
}

enum AlmondCakeIngredient {
    case flower
    case sugar
    case yeast
    case eggs
    case almonds
    case salt
}

然后像这样烤蛋糕：

// in chocolate cake class / struct:
func bake(with ingredients: [ChocolateCakeIngredient]) -> ChocolateCake
// in almond cake class / struct:
func bake(with ingredients: [AlmondCakeIngredient]) -> AlmondCake

但是我不得不一遍又一遍地重新定义相同的成分，因为两种蛋糕都使用了许多成分。我真的不想那样做——尤其是在枚举案例中附加了库存编号为rawValues。

这让我想到了一个问题，在 Swift 中是否有办法将一个枚举限制为另一个枚举的某些情况？类似（伪代码）：

enum ChocolateCakeIngredient: Ingredient {
    allowedCases:
        case flower
        case sugar
        case eggs
        case milk
        case chocolate
}

enum AlmondCakeIngredient: Ingredient {
    allowedCases:
        case flower
        case sugar
        case yeast
        case eggs
        case almonds
        case salt
}

这样的组合可能吗？我该怎么做？

或者我可以在这种情况下使用另一种模式？

---

更新

从这个问题的所有 cmets 和答案中，我认为我为这个问题选择的示例有点不合适，因为它没有归结问题的本质，并且在类型安全方面留下了漏洞。

由于此页面上的所有帖子都与此特定示例相关，因此我在 Stackoverflow 上创建了一个新问题，其中包含一个更易于理解且一针见血的示例：

➡️Same question with a more specific example

Answer 1

我认为不可能在编译时执行这样的检查。这是在运行时构建代码以执行此操作的一种方法：

enum Ingredient: Int {
  case flour = 1
  case sugar = 2
  case yeast = 3
  case eggs = 4
  case milk = 5
  case almonds = 6
  case chocolate = 7
  case salt = 8
}

protocol Cake {
  init()
  static var validIngredients: [Ingredient] { get }
}

extension Cake {
  static func areIngredientsAllowed(_ ingredients: [Ingredient]) -> Bool {
    for ingredient in ingredients {
      if !validIngredients.contains(ingredient) {
        return false
      }
    }
    return true
  }
}

class ChocolateCake: Cake {
  required init() {}
  static var validIngredients: [Ingredient] = [.flour, .sugar, .eggs, .milk, .chocolate]
}

class AlmondCake: Cake {
  required init() {}
  static var validIngredients: [Ingredient] = [.flour, .sugar, .yeast, .eggs, .almonds, .salt]
}

bake 方法如下所示：

func bake<C: Cake>(ingredients: [Ingredient]) -> C {

  guard C.areIngredientsAllowed(ingredients) else {
    fatalError()
  }

  let cake = C()
  // TODO: Let's bake!
  return cake
}

现在我可以说：

let almondCake: AlmondCake = bake(ingredients: ingredients)

...并确保只使用有效成分。

Answer 2

另一种方法：使用选项集类型

或者我可以在这种情况下使用另一种模式？

另一种方法是让您的Ingredient 成为OptionSet 类型（符合协议OptionsSet 的类型）：

• https://developer.apple.com/reference/swift/optionset

例如

struct Ingredients: OptionSet {
    let rawValue: UInt8

    static let flower    = Ingredients(rawValue: 1 << 0) //0b00000001
    static let sugar     = Ingredients(rawValue: 1 << 1) //0b00000010
    static let yeast     = Ingredients(rawValue: 1 << 2) //0b00000100
    static let eggs      = Ingredients(rawValue: 1 << 3) //0b00001000
    static let milk      = Ingredients(rawValue: 1 << 4) //0b00010000
    static let almonds   = Ingredients(rawValue: 1 << 5) //0b00100000
    static let chocolate = Ingredients(rawValue: 1 << 6) //0b01000000
    static let salt      = Ingredients(rawValue: 1 << 7) //0b10000000

    // some given ingredient sets
    static let chocolateCakeIngredients: Ingredients = 
        [.flower, .sugar, .eggs, .milk, .chocolate]
    static let almondCakeIngredients: Ingredients = 
        [.flower, .sugar, .yeast, .eggs, .almonds, .salt]
}

应用于您的bake(with:) 示例，其中员工/开发人员尝试在bake(with:) 的主体中实现巧克力蛋糕的烘焙：

/* dummy cake */
struct Cake {
    var ingredients: Ingredients
    init(_ ingredients: Ingredients) { self.ingredients = ingredients }
}

func bake(with ingredients: Ingredients) -> Cake? {
    // lets (attempt to) bake a chokolate cake
    let chocolateCakeWithIngredients: Ingredients = 
        [.flower, .sugar, .yeast, .milk, .chocolate]
                        // ^^^^^ ups, employee misplaced .eggs for .yeast!

    /* alternatively, add ingredients one at a time / subset at a time
    var chocolateCakeWithIngredients: Ingredients = []
    chocolateCakeWithIngredients.formUnion(.yeast) // ups, employee misplaced .eggs for .yeast!
    chocolateCakeWithIngredients.formUnion([.flower, .sugar, .milk, .chocolate]) */

    /* runtime check that ingredients are valid */
    /* ---------------------------------------- */

    // one alternative, invalidate the cake baking by nil return if 
    // invalid ingredients are used
    guard ingredients.contains(chocolateCakeWithIngredients) else { return nil }
    return Cake(chocolateCakeWithIngredients)

    /* ... or remove invalid ingredients prior to baking the cake 
    return Cake(chocolateCakeWithIngredients.intersection(ingredients)) */

    /* ... or, make bake(with:) a throwing function, which throws and error
       case containing the set of invalid ingredients for some given attempted baking */
}

使用给定的可用巧克力蛋糕原料致电bake(with:)：

if let cake = bake(with: Ingredients.chocolateCakeIngredients) {
    print("We baked a chocolate cake!")
}
else {
    print("Invalid ingredients used for the chocolate cake ...")
} // Invalid ingredients used for the chocolate cake ...

Answer 3

静态解决方案：

如果配方数量始终相同，则可以在枚举中使用函数：

    enum Ingredient {
        case chocolate
        case almond

        func bake() -> Cake {
            switch self {
            case chocolate:
                print("chocolate")
                /*
                 return a Chocolate Cake based on:

                 500g flower
                 300g sugar
                 3 eggs
                 200ml milk
                 200g chocolate
                 */
            case almond:
                print("almond")
                /*
                 return an Almond Cake based on:

                 300g flower
                 200g sugar
                 20g yeast
                 200g almonds
                 5 eggs
                 2g salt
                 */
            }
        }
    }

用法：

// bake chocolate cake
let bakedChocolateCake = Ingredient.chocolate.bake()

// bake a almond cake
let bakedAlmondCake = Ingredient.almond.bake()

动态解决方案：

如果配方数量是可变的——这就是我的假设——我通过使用一个单独的 model 类有点作弊:)

如下：

class Recipe {
    private var flower = 0
    private var sugar = 0
    private var yeast = 0
    private var eggs = 0
    private var milk = 0
    private var almonds = 0
    private var chocolate = 0
    private var salt = 0

    // init for creating a chocolate cake:
    init(flower: Int, sugar: Int, eggs: Int, milk: Int, chocolate: Int) {
        self.flower = flower
        self.sugar = sugar
        self.eggs = eggs
        self.milk = milk
        self.chocolate = chocolate
    }

    // init for creating an almond cake:
    init(flower: Int, sugar: Int, yeast: Int, almonds: Int, eggs: Int, salt: Int) {
        self.flower = flower
        self.sugar = sugar
        self.yeast = yeast
        self.almonds = almonds
        self.eggs = eggs
        self.salt = salt
    }
}

enum Ingredient {
    case chocolate
    case almond

    func bake(recipe: Recipe) -> Cake? {
        switch self {
        case chocolate:
            print("chocolate")
            if recipe.yeast > 0 || recipe.almonds > 0 || recipe.salt > 0 {
                return nil
                // or maybe a fatal error!!
            }

            // return a Chocolate Cake based on the given recipe:
        case almond:
            print("almond")
            if recipe.chocolate > 0 {
                return nil
                // or maybe a fatal error!!
            }

            // return an Almond Cake based on the given recipe:
        }
    }
}

用法：

// bake chocolate cake with a custom recipe
let bakedChocolateCake = Ingredient.chocolate.bake(Recipe(flower: 500, sugar: 300, eggs: 3, milk: 200, chocolate: 200)

// bake almond cake with a custom recipe
let bakedAlmondCake = Ingredient.chocolate.bake(Recipe(flower: 300, sugar: 200, yeast: 20, almonds: 200, eggs: 5, salt: 2))

即使这些不是您的案例的最佳解决方案，我希望它有所帮助。

Answer 4

你可以在 Swift 中做这样的事情：

enum Ingredients {
    struct Flower { }
    struct Sugar { }
    struct Yeast { }
    struct Eggs { }
    struct Milc { }
}

protocol ChocolateCakeIngredient { }
extension Sugar: ChocolateCakeIngredient { }
extension Eggs: ChocolateCakeIngredient { }
...

func bake(ingredients: [ChocolateCakeIngredient]) { }

在这个例子中，我使用枚举 Ingredients 作为我所有成分的命名空间。这也有助于代码完成。

然后，为每个配方创建一个协议，并使该配方中的成分符合该协议。

虽然这应该可以解决您的问题，但我不确定您是否应该这样做。这（以及您的伪代码）将强制在烘烤巧克力蛋糕时没有人可以传递不属于巧克力蛋糕的成分。但是，它不会禁止任何人尝试使用空数组或类似的东西调用bake(with ingredients:)。因此，您实际上不会通过您的设计获得任何安全性。

Answer 5

我认为您应该将特定食谱的成分列为：

let chocolateCakeIngredients: [Ingredient] = [.flower, ...]

然后只需检查该列表是否包含所需的成分。