andre/the-swift-programming-language-in-chinese
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

enum for swift3.0

Browse Source
This commit is contained in:
shanks
2016-09-24 06:57:01 +08:00
parent fa3f0bc8ac
commit 9c27e01947
1 changed files with 74 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
source/chapter2/08_Enumerations.md
View File

@ -10,11 +10,15 @@
> 2.1 > 2.1
> 翻译：[Channe](https://github.com/Channe) > 翻译：[Channe](https://github.com/Channe)
> 校对：[shanks](http://codebuild.me)， > 校对：[shanks](http://codebuild.me)
> 2.2 > 2.2
> 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-13 > 翻译+校对：[SketchK](https://github.com/SketchK) 2016-05-13
> 2.2
> 翻译+校对：[shanks](https://codebuild.me) 2016-09-24
本页内容包含： 本页内容包含：
- [枚举语法（Enumeration Syntax）](#enumeration_syntax) - [枚举语法（Enumeration Syntax）](#enumeration_syntax)
@ -27,11 +31,11 @@
如果你熟悉 C 语言，你会知道在 C 语言中，枚举会为一组整型值分配相关联的名称。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。 如果你熟悉 C 语言，你会知道在 C 语言中，枚举会为一组整型值分配相关联的名称。Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为“原始”值），则该值的类型可以是字符串，字符，或是一个整型值或浮点数。
此外，枚举成员可以指定任意类型的关联值存储到枚举成员中，就像其他语言中的联合体（unions）和变体（variants）。每一个枚举成员都可以有适当类型的关联值。 此外，枚举成员可以指定*任意*类型的关联值存储到枚举成员中，就像其他语言中的联合体（unions）和变体（variants）。你可以在一个枚举中定义一组相关的枚举成员，每一个枚举成员都可以有适当类型的关联值。
在 Swift 中，枚举类型是一等（first-class）类型。它们采用了很多在传统上只被类（class）所支持的特性，例如计算型属性（computed properties），用于提供枚举值的附加信息，实例方法（instance methods），用于提供和枚举值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始实现的基础上扩展它们的功能；还可以遵守协议（protocols）来提供标准的功能。 在 Swift 中，枚举类型是一等（first-class）类型。它们采用了很多在传统上只被类（class）所支持的特性，例如计算属性（computed properties），用于提供枚举值的附加信息，实例方法（instance methods），用于提供和枚举值相关联的功能。枚举也可以定义构造函数（initializers）来提供一个初始值；可以在原始实现的基础上扩展它们的功能；还可以遵循协议（protocols）来提供标准的功能。
欲了解更多相关信息，请参见[属性（Properties）](./10_Properties.html)，[方法（Methods）](./11_Methods.html)，[构造过程（Initialization）](./14_Initialization.html)，[扩展（Extensions）](./21_Extensions.html)和[协议（Protocols）](./22_Protocols.html)。 想了解更多相关信息，请参见[属性（Properties）](./10_Properties.html)，[方法（Methods）](./11_Methods.html)，[构造过程（Initialization）](./14_Initialization.html)，[扩展（Extensions）](./21_Extensions.html)和[协议（Protocols）](./22_Protocols.html)。
<a name="enumeration_syntax"></a> <a name="enumeration_syntax"></a>
## 枚举语法 ## 枚举语法
@ -48,36 +52,36 @@ enum SomeEnumeration {
```swift ```swift
enum CompassPoint { enum CompassPoint {
case North case north
case South case south
case East case east
case West case west
} }
``` ```
枚举中定义的值（如 `North`，`South`，`East`和`West`）是这个枚举的*成员值*（或*成员*）。你使用`case`关键字来定义一个新的枚举成员值。 枚举中定义的值（如 `north `，`south`，`east`和`west`）是这个枚举的*成员值*（或*成员*）。你可以使用`case`关键字来定义一个新的枚举成员值。
> 注意 > 注意
> 与 C 和 Objective-C 不同，Swift 的枚举成员在被创建时不会被赋予一个默认的整型值。在上面的`CompassPoint`例子中，`North`，`South`，`East`和`West`不会被隐式地赋值为`0`，`1`，`2`和`3`。相反，这些枚举成员本身就是完备的值，这些值的类型是已经明确定义好的`CompassPoint`类型。 > 与 C 和 Objective-C 不同，Swift 的枚举成员在被创建时不会被赋予一个默认的整型值。在上面的`CompassPoint`例子中，`north`，`south`，`east`和`west`不会被隐式地赋值为`0`，`1`，`2`和`3`。相反，这些枚举成员本身就是完备的值，这些值的类型是已经明确定义好的`CompassPoint`类型。
多个成员值可以出现在同一行上，用逗号隔开： 多个成员值可以出现在同一行上，用逗号隔开：
```swift ```swift
enum Planet { enum Planet {
case Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
} }
``` ```
每个枚举定义了一个全新的类型。像 Swift 中其他类型一样，它们的名字（例如`CompassPoint`和`Planet`）应该以一个大写字母开头。给枚举类型起一个单数名字而不是复数名字，以便于读起来更加容易理解： 每个枚举定义了一个全新的类型。像 Swift 中其他类型一样，它们的名字（例如`CompassPoint`和`Planet`）应该以一个大写字母开头。给枚举类型起一个单数名字而不是复数名字，以便于读起来更加容易理解：
```swift ```swift
var directionToHead = CompassPoint.West var directionToHead = CompassPoint.west
``` ```
`directionToHead`的类型可以在它被`CompassPoint`的某个值初始化时推断出来。一旦`directionToHead`被声明为`CompassPoint`类型，你可以使用更简短的点语法将其设置为另一个`CompassPoint`的值： `directionToHead`的类型可以在它被`CompassPoint`的某个值初始化时推断出来。一旦`directionToHead`被声明为`CompassPoint`类型，你可以使用更简短的点语法将其设置为另一个`CompassPoint`的值：
```swift ```swift
directionToHead = .East directionToHead = .east
``` ```
当`directionToHead`的类型已知时，再次为其赋值可以省略枚举类型名。在使用具有显式类型的枚举值时，这种写法让代码具有更好的可读性。 当`directionToHead`的类型已知时，再次为其赋值可以省略枚举类型名。在使用具有显式类型的枚举值时，这种写法让代码具有更好的可读性。
@ -88,15 +92,15 @@ directionToHead = .East
你可以使用`switch`语句匹配单个枚举值： 你可以使用`switch`语句匹配单个枚举值：
```swift ```swift
directionToHead = .South directionToHead = .south
switch directionToHead { switch directionToHead {
case .North: case .north:
print("Lots of planets have a north") print("Lots of planets have a north")
case .South: case .south:
print("Watch out for penguins") print("Watch out for penguins")
case .East: case .east:
print("Where the sun rises") print("Where the sun rises")
case .West: case .west:
print("Where the skies are blue") print("Where the skies are blue")
} }
// 输出 "Watch out for penguins” // 输出 "Watch out for penguins”
@ -104,18 +108,18 @@ switch directionToHead {
你可以这样理解这段代码： 你可以这样理解这段代码：
“判断`directionToHead`的值。当它等于`.North`，打印`“Lots of planets have a north”`。当它等于`.South`，打印`“Watch out for penguins”`。” “判断`directionToHead`的值。当它等于`.north`，打印`“Lots of planets have a north”`。当它等于`.south`，打印`“Watch out for penguins”`。”
……以此类推。 ……以此类推。
正如在[控制流（Control Flow）](./05_Control_Flow.html)中介绍的那样，在判断一个枚举类型的值时，`switch`语句必须穷举所有情况。如果忽略了`.West`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。强制穷举确保了枚举成员不会被意外遗漏。 正如在[控制流（Control Flow）](./05_Control_Flow.html)中介绍的那样，在判断一个枚举类型的值时，`switch`语句必须穷举所有情况。如果忽略了`.west`这种情况，上面那段代码将无法通过编译，因为它没有考虑到`CompassPoint`的全部成员。强制穷举确保了枚举成员不会被意外遗漏。
当不需要匹配每个枚举成员的时候，你可以提供一个`default`分支来涵盖所有未明确处理的枚举成员： 当不需要匹配每个枚举成员的时候，你可以提供一个`default`分支来涵盖所有未明确处理的枚举成员：
```swift ```swift
let somePlanet = Planet.Earth let somePlanet = Planet.earth
switch somePlanet { switch somePlanet {
case .Earth: case .earth:
print("Mostly harmless") print("Mostly harmless")
default: default:
print("Not a safe place for humans") print("Not a safe place for humans")
@ -126,7 +130,7 @@ default:
<a name="associated_values"></a> <a name="associated_values"></a>
## 关联值（Associated Values） ## 关联值（Associated Values）
上一小节的例子演示了如何定义和分类枚举的成员。你可以为`Planet.Earth`设置一个常量或者变量，并在赋值之后查看这个值。然而，有时候能够把其他类型的*关联值*和成员值一起存储起来会很有用。这能让你连同成员值一起存储额外的自定义信息，并且你每次在代码中使用该枚举成员时，还可以修改这个关联值。 上一小节的例子演示了如何定义和分类枚举的成员。你可以为`Planet.earth`设置一个常量或者变量，并在赋值之后查看这个值。然而，有时候能够把其他类型的*关联值*和成员值一起存储起来会很有用。这能让你连同成员值一起存储额外的自定义信息，并且你每次在代码中使用该枚举成员时，还可以修改这个关联值。
你可以定义 Swift 枚举来存储任意类型的关联值，如果需要的话，每个枚举成员的关联值类型可以各不相同。枚举的这种特性跟其他语言中的可识别联合（discriminated unions），标签联合（tagged unions），或者变体（variants）相似。 你可以定义 Swift 枚举来存储任意类型的关联值，如果需要的话，每个枚举成员的关联值类型可以各不相同。枚举的这种特性跟其他语言中的可识别联合（discriminated unions），标签联合（tagged unions），或者变体（variants）相似。
@ -138,46 +142,46 @@ default:
<img width="169" height="169" alt="" src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/barcode_QR_2x.png"> <img width="169" height="169" alt="" src="https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Art/barcode_QR_2x.png">
这便于库存跟踪系统用包含四个整型值的元组存储 UPC-A 码，以及用任意长度的字符串储存 QR 码。 这便于库存跟踪系统用包含四个整型值的元组存储 UPC 码，以及用任意长度的字符串储存 QR 码。
在 Swift 中，使用如下方式定义表示两种商品条形码的枚举： 在 Swift 中，使用如下方式定义表示两种商品条形码的枚举：
```swift ```swift
enum Barcode { enum Barcode {
case UPCA(Int, Int, Int, Int) case upc(Int, Int, Int, Int)
case QRCode(String) case qrCode(String)
} }
``` ```
以上代码可以这么理解： 以上代码可以这么理解：
“定义一个名为`Barcode`的枚举类型，它的一个成员值是具有`(Int，Int，Int，Int)`类型关联值的`UPCA`，另一个成员值是具有`String`类型关联值的`QRCode`。” “定义一个名为`Barcode`的枚举类型，它的一个成员值是具有`(Int，Int，Int，Int)`类型关联值的`upc`，另一个成员值是具有`String`类型关联值的`qrCode`。”
这个定义不提供任何`Int`或`String`类型的关联值，它只是定义了，当`Barcode`常量和变量等于`Barcode.UPCA`或`Barcode.QRCode`时，可以存储的关联值的类型。 这个定义不提供任何`Int`或`String`类型的关联值，它只是定义了，当`Barcode`常量和变量等于`Barcode.upc`或`Barcode.qrCode`时，可以存储的关联值的类型。
然后可以使用任意一种条形码类型创建新的条形码，例如： 然后可以使用任意一种条形码类型创建新的条形码，例如：
```swift ```swift
var productBarcode = Barcode.UPCA(8, 85909, 51226, 3) var productBarcode = Barcode.upc(8, 85909, 51226, 3)
``` ```
上面的例子创建了一个名为`productBarcode`的变量，并将`Barcode.UPCA`赋值给它，关联的元组值为`(8, 85909, 51226, 3)`。 上面的例子创建了一个名为`productBarcode`的变量，并将`Barcode.upc`赋值给它，关联的元组值为`(8, 85909, 51226, 3)`。
同一个商品可以被分配一个不同类型的条形码，例如： 同一个商品可以被分配一个不同类型的条形码，例如：
```swift ```swift
productBarcode = .QRCode("ABCDEFGHIJKLMNOP") productBarcode = .qrCode("ABCDEFGHIJKLMNOP")
``` ```
这时，原始的`Barcode.UPCA`和其整数关联值被新的`Barcode.QRCode`和其字符串关联值所替代。`Barcode`类型的常量和变量可以存储一个`.UPCA`或者一个`.QRCode`（连同它们的关联值），但是在同一时间只能存储这两个值中的一个。 这时，原始的`Barcode.upc`和其整数关联值被新的`Barcode.qrCode`和其字符串关联值所替代。`Barcode`类型的常量和变量可以存储一个`.upc`或者一个`.qrCode`（连同它们的关联值），但是在同一时间只能存储这两个值中的一个。
像先前那样，可以使用一个 switch 语句来检查不同的条形码类型。然而，这一次，关联值可以被提取出来作为 switch 语句的一部分。你可以在`switch`的 case 分支代码中提取每个关联值作为一个常量（用`let`前缀）或者作为一个变量（用`var`前缀）来使用： 像先前那样，可以使用一个 switch 语句来检查不同的条形码类型。然而，这一次，关联值可以被提取出来作为 switch 语句的一部分。你可以在`switch`的 case 分支代码中提取每个关联值作为一个常量（用`let`前缀）或者作为一个变量（用`var`前缀）来使用：
```swift ```swift
switch productBarcode { switch productBarcode {
case .UPCA(let numberSystem, let manufacturer, let product, let check): case .upc(let numberSystem, let manufacturer, let product, let check):
print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).") print("UPC: \(numberSystem), \(manufacturer), \(product), \(check).")
case .QRCode(let productCode): case .qrCode(let productCode):
print("QR code: \(productCode).") print("QR code: \(productCode).")
} }
// 输出 "QR code: ABCDEFGHIJKLMNOP." // 输出 "QR code: ABCDEFGHIJKLMNOP."
@ -187,9 +191,9 @@ case .QRCode(let productCode):
```swift ```swift
switch productBarcode { switch productBarcode {
case let .UPCA(numberSystem, manufacturer, product, check): case let .upc(numberSystem, manufacturer, product, check):
print("UPC-A: \(numberSystem), \(manufacturer), \(product), \(check).") print("UPC: \(numberSystem), \(manufacturer), \(product), \(check).")
case let .QRCode(productCode): case let .qrCode(productCode):
print("QR code: \(productCode).") print("QR code: \(productCode).")
} }
// 输出 "QR code: ABCDEFGHIJKLMNOP." // 输出 "QR code: ABCDEFGHIJKLMNOP."
@ -204,9 +208,9 @@ case let .QRCode(productCode):
```swift ```swift
enum ASCIIControlCharacter: Character { enum ASCIIControlCharacter: Character {
case Tab = "\t" case tab = "\t"
case LineFeed = "\n" case lineFeed = "\n"
case CarriageReturn = "\r" case carriageReturn = "\r"
} }
``` ```
@ -229,11 +233,11 @@ enum ASCIIControlCharacter: Character {
```swift ```swift
enum Planet: Int { enum Planet: Int {
case Mercury = 1, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
} }
``` ```
在上面的例子中，`Plant.Mercury`的显式原始值为`1`，`Planet.Venus`的隐式原始值为`2`，依次类推。 在上面的例子中，`Plant.mercury`的显式原始值为`1`，`Planet.venus`的隐式原始值为`2`，依次类推。
当使用字符串作为枚举类型的原始值时，每个枚举成员的隐式原始值为该枚举成员的名称。 当使用字符串作为枚举类型的原始值时，每个枚举成员的隐式原始值为该枚举成员的名称。
@ -241,20 +245,20 @@ enum Planet: Int {
```swift ```swift
enum CompassPoint: String { enum CompassPoint: String {
case North, South, East, West case north, south, east, west
} }
``` ```
上面例子中，`CompassPoint.South`拥有隐式原始值`South`，依次类推。 上面例子中，`CompassPoint.south`拥有隐式原始值`south`，依次类推。
使用枚举成员的`rawValue`属性可以访问该枚举成员的原始值： 使用枚举成员的`rawValue`属性可以访问该枚举成员的原始值：
```swift ```swift
let earthsOrder = Planet.Earth.rawValue let earthsOrder = Planet.earth.rawValue
// earthsOrder 值为 3 // earthsOrder 值为 3
let sunsetDirection = CompassPoint.West.rawValue let sunsetDirection = CompassPoint.west.rawValue
// sunsetDirection 值为 "West" // sunsetDirection 值为 "west"
``` ```
<a name="initializing_from_a_raw_value"></a> <a name="initializing_from_a_raw_value"></a>
@ -262,11 +266,11 @@ let sunsetDirection = CompassPoint.West.rawValue
如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法接收一个叫做`rawValue`的参数，参数类型即为原始值类型，返回值则是枚举成员或`nil`。你可以使用这个初始化方法来创建一个新的枚举实例。 如果在定义枚举类型的时候使用了原始值，那么将会自动获得一个初始化方法，这个方法接收一个叫做`rawValue`的参数，参数类型即为原始值类型，返回值则是枚举成员或`nil`。你可以使用这个初始化方法来创建一个新的枚举实例。
这个例子利用原始值`7`创建了枚举成员`Uranus`： 这个例子利用原始值`7`创建了枚举成员`uranus`：
```swift ```swift
let possiblePlanet = Planet(rawValue: 7) let possiblePlanet = Planet(rawValue: 7)
// possiblePlanet 类型为 Planet? 值为 Planet.Uranus // possiblePlanet 类型为 Planet? 值为 Planet.uranus
``` ```
然而，并非所有`Int`值都可以找到一个匹配的行星。因此，原始值构造器总是返回一个*可选*的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或者说“可选的`Planet`”。 然而，并非所有`Int`值都可以找到一个匹配的行星。因此，原始值构造器总是返回一个*可选*的枚举成员。在上面的例子中，`possiblePlanet`是`Planet?`类型，或者说“可选的`Planet`”。
@ -274,13 +278,13 @@ let possiblePlanet = Planet(rawValue: 7)
> 注意 > 注意
> 原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[可失败构造器](../chapter3/05_Declarations.html#failable_initializers) > 原始值构造器是一个可失败构造器，因为并不是每一个原始值都有与之对应的枚举成员。更多信息请参见[可失败构造器](../chapter3/05_Declarations.html#failable_initializers)
如果你试图寻找一个位置为`9`的行星，通过原始值构造器返回的可选`Planet`值将是`nil`： 如果你试图寻找一个位置为`11`的行星，通过原始值构造器返回的可选`Planet`值将是`nil`：
```swift ```swift
let positionToFind = 9 let positionToFind = 11
if let somePlanet = Planet(rawValue: positionToFind) { if let somePlanet = Planet(rawValue: positionToFind) {
switch somePlanet { switch somePlanet {
case .Earth: case .earth:
print("Mostly harmless") print("Mostly harmless")
default: default:
print("Not a safe place for humans") print("Not a safe place for humans")
@ -288,10 +292,10 @@ if let somePlanet = Planet(rawValue: positionToFind) {
} else { } else {
print("There isn't a planet at position \(positionToFind)") print("There isn't a planet at position \(positionToFind)")
} }
// 输出 "There isn't a planet at position 9 // 输出 "There isn't a planet at position 11
``` ```
这个例子使用了可选绑定（optional binding），试图通过原始值`9`来访问一个行星。`if let somePlanet = Planet(rawValue: 9)`语句创建了一个可选`Planet`，如果可选`Planet`的值存在，就会赋值给`somePlanet`。在这个例子中，无法检索到位置为`9`的行星，所以`else`分支被执行。 这个例子使用了可选绑定（optional binding），试图通过原始值`11`来访问一个行星。`if let somePlanet = Planet(rawValue: 11)`语句创建了一个可选`Planet`，如果可选`Planet`的值存在，就会赋值给`somePlanet`。在这个例子中，无法检索到位置为`11`的行星，所以`else`分支被执行。
<a name="recursive_enumerations"></a> <a name="recursive_enumerations"></a>
## 递归枚举（Recursive Enumerations） ## 递归枚举（Recursive Enumerations）
@ -303,9 +307,9 @@ if let somePlanet = Planet(rawValue: positionToFind) {
```swift ```swift
enum ArithmeticExpression { enum ArithmeticExpression {
case Number(Int) case number(Int)
indirect case Addition(ArithmeticExpression, ArithmeticExpression) indirect case addition(ArithmeticExpression, ArithmeticExpression)
indirect case Multiplication(ArithmeticExpression, ArithmeticExpression) indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
} }
``` ```
@ -313,31 +317,31 @@ enum ArithmeticExpression {
```swift ```swift
indirect enum ArithmeticExpression { indirect enum ArithmeticExpression {
case Number(Int) case number(Int)
case Addition(ArithmeticExpression, ArithmeticExpression) case addition(ArithmeticExpression, ArithmeticExpression)
case Multiplication(ArithmeticExpression, ArithmeticExpression) case multiplication(ArithmeticExpression, ArithmeticExpression)
} }
``` ```
上面定义的枚举类型可以存储三种算术表达式：纯数字、两个表达式相加、两个表达式相乘。枚举成员`Addition`和`Multiplication`的关联值也是算术表达式——这些关联值使得嵌套表达式成为可能。例如，表达式`(5 + 4) * 2`，乘号右边是一个数字，左边则是另一个表达式。因为数据是嵌套的，因而用来存储数据的枚举类型也需要支持这种嵌套——这意味着枚举类型需要支持递归。下面的代码展示了使用`ArithmeticExpression `这个递归枚举创建表达式`(5 + 4) * 2` 上面定义的枚举类型可以存储三种算术表达式：纯数字、两个表达式相加、两个表达式相乘。枚举成员`addition`和`multiplication`的关联值也是算术表达式——这些关联值使得嵌套表达式成为可能。例如，表达式`(5 + 4) * 2`，乘号右边是一个数字，左边则是另一个表达式。因为数据是嵌套的，因而用来存储数据的枚举类型也需要支持这种嵌套——这意味着枚举类型需要支持递归。下面的代码展示了使用`ArithmeticExpression `这个递归枚举创建表达式`(5 + 4) * 2`
```swift ```swift
let five = ArithmeticExpression.Number(5) let five = ArithmeticExpression.number(5)
let four = ArithmeticExpression.Number(4) let four = ArithmeticExpression.number(4)
let sum = ArithmeticExpression.Addition(five, four) let sum = ArithmeticExpression.addition(five, four)
let product = ArithmeticExpression.Multiplication(sum, ArithmeticExpression.Number(2)) let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))
``` ```
要操作具有递归性质的数据结构，使用递归函数是一种直截了当的方式。例如，下面是一个对算术表达式求值的函数： 要操作具有递归性质的数据结构，使用递归函数是一种直截了当的方式。例如，下面是一个对算术表达式求值的函数：
```swift ```swift
func evaluate(expression: ArithmeticExpression) -> Int { func evaluate(_ expression: ArithmeticExpression) -> Int {
switch expression { switch expression {
case .Number(let value): case let .number(value):
return value return value
case .Addition(let left, let right): case let .addition(left, right):
return evaluate(left) + evaluate(right) return evaluate(left) + evaluate(right)
case .Multiplication(let left, let right): case let .multiplication(left, right):
return evaluate(left) * evaluate(right) return evaluate(left) * evaluate(right)
} }
} }