Ios Swift：使用闭包的枚举？

我正在创建一个应用程序，其中可以对无限数量的节点应用无限数量的规则

我计划使用核心数据作为数据存储，并在节点和规则之间创建一个简单的一对多关系

在objective-c中，我可能会为每个规则创建类，并使它们符合协议

NSArray *ruleClassNames = @[@"SimpleRuleA",@"SimpleRuleB",@"BigFatComplicatedRule"];

int ruleType = [someNode.rules firstObject];
Class class = NSClassFromString(ruleClassNames[ruleType]);

[(ruleClassProtocol*)class performSelector:@selector(runRuleOnNode:) withObject:someNode];

在swift中，最优雅的方法是什么？

解决方案 如果我们想在

枚举中添加
闭包
，首先让我们定义
闭包的类型

typealias Logic = () -> (String)

然后，
枚举
：

enum Rule {
    case SimpleRuleA(Logic)
    case SimpleRuleB(Logic)
    case BigFatComplicatedRule(Logic)
}

就这样！现在让我们看看如何使用这个

用法
让我们创建两个
逻辑
：

现在是一个处理
规则的函数

func processRule(rule:Rule) -> String {
    switch rule {
    case .SimpleRuleA(let logic): return "Simple Rule A, logic: \(logic())"
    case .SimpleRuleB(let logic): return "Simple Rule B, logic: \(logic())"
    case .BigFatComplicatedRule(let logic): return "Big Fat Complicated Rule, logic: \(logic())"
    }
}

最后，让我们将每个可能的规则与每个可能的
逻辑组合起来

let aWithLogic0 = Rule.SimpleRuleA(logic0)
let aWithLogic1 = Rule.SimpleRuleA(logic1)
let bWithLogic0 = Rule.SimpleRuleB(logic0)
let bWithLogic1 = Rule.SimpleRuleB(logic1)
let fatWithLogic0 = Rule.BigFatComplicatedRule(logic0)
let fatWithLogic1 = Rule.BigFatComplicatedRule(logic1)

。。。让我们测试一下

processRule(aWithLogic0) // "Simple Rule A, logic: Logic 0"
processRule(aWithLogic1) // "Simple Rule A, logic: Logic 1"
processRule(bWithLogic0) // "Simple Rule B, logic: Logic 0"
processRule(bWithLogic1) // "Simple Rule B, logic: Logic 1"
processRule(fatWithLogic0) // "Big Fat Complicated Rule, logic: Logic 0"
processRule(fatWithLogic1) // "Big Fat Complicated Rule, logic: Logic 1"

这个解决方案与您的想法接近吗

    enum FunctionEnum
   {
     case binaryOperation((Double,Double)->Double)
     constant(Double)
   }

1.您可以将值与枚举案例关联，因此它在此处也具有类型，例如binaryOperation的类型
（（Double，Double）->Double）这意味着它属于一种接受两个Double并返回一个的闭包类型
你能定义“优雅”吗
enum
是用来处理
switch
的，所以我真的不明白为什么要使用enum并避免使用
switch
@Sulthan您显然理解enum的概念，但请再次阅读问题，看看您是否能想出一个解决方案……嗯，您的Obj-C代码可以很容易地写入Swift（当然，你会直接使用类型，而不是使用类型的名称）。这是否优雅是一个品味的问题。
    enum FunctionEnum
   {
     case binaryOperation((Double,Double)->Double)
     constant(Double)
   }