Swift：使用闭包的枚举？

Question

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

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

在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中这样做最优雅的方式是什么？

Answer 1

解

如果我们想要为enum添加closure首先让我们定义closure的类型。

typealias Logic = () -> (String)

然后是enum ：

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

而已！ 现在让我们看看如何使用它。

用法

让我们创建几个Logic(s) ：

let logic0 : Logic = { return "Logic 0" }
let logic1 : Logic = { return "Logic 1" }

现在是处理Rule的函数

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())"
    }
}

最后让我们将每个可能的规则与每个可能的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"

这个解决方案是否接近您的想法？

Answer 2

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

1.你可以将值与枚举案例相关联，因此它在这里也有类型，例如binaryOperation是类型（（Double，Double） - > Double），这意味着它的类型是一个闭包，它接受两个双精度并返回一个