常量模式#

常量模式可以是整数字面量、字节字面量、浮点数字面量、Rune字面量、布尔字面量、字符串字面量**(不支持字符串插值)**、Unit 字面量

常量模式中字面量的类型需要和 selector 的类型一致, selector 和一个常量模式匹配成功的条件是 selector 与常量模式中的字面量相等(这里指值相等)

常量模式的语法定义为:

1
constantPattern
2
    : literalConstant
3
    ;

使用常量模式的例子如下:

1
func f() {
2
    let score: Int64 = 90
3
    var scoreResult: String = match (score) {
4
        case 0 => "zero"
5
        case 10 | 20 | 30 | 40 | 50 => "fail"
6
        case 70 | 80 => "good"
7
        case 90 => "excellent" // matched
8
        case _ => "not a valid score"
9
    }
10
}

需要注意的是, 浮点数字面量匹配在常量模式中遵循浮点数的判等规则, 会和判等存在一样的精度问题

常量模式是最简单基础的用法, 就是判断 selector 与 pattern 是否匹配, 然后执行目标语句

通配符模式#

通配符模式使用下划线_表示, 它可以匹配任意值, 常用于部分匹配(例如作为占位符)或作为match表达式的最后一个 pattern 来匹配其它case未覆盖到的情况

通配符模式的语法定义为:

1
wildcardPattern
2
    : '_'
3
    ;

使用通配符模式的例子如下:

1
let score: Int64 = 90
2
var scoreResult: String = match (score) {
3
    case 60 => "pass"
4
    case 70 | 80 => "good"
5
    case 90 | 100 => "excellent" // matched
6
    case _ => "fail"             // wildcard pattern: used for default case
7
}

通配符, 匹配任意值

如果作为第一个 pattern , 那就只能命中第一个case了

绑定模式#

绑定模式同样可以匹配任意值, 但与通配符模式不同的是, 绑定模式会将匹配到的值绑定到 binding pattern 中定义的变量, 以便在=>之后的表达式中进行访问

绑定模式的语法定义为:

1
varBindingPattern
2
    : identifier
3
    ;

绑定模式中定义的变量是不可变的

使用绑定模式的例子如下:

1
let score: Int64 = 90
2
var scoreResult: String = match (score) {
3
    case 60 => "pass"
4
    case 70 | 80 => "good"
5
    case 90 | 100 => "excellent" // matched
6
    case failScore =>            // binding pattern
7
        let passNeed = 60 - failScore
8
        "failed with ${failScore}, and ${passNeed} need to pass"
9
}

绑定模式中定义的变量, 作用域从第一次出现的位置处开始至下一个case之前

需要注意, 使用|连接多个模式时不能使用绑定模式, 也不可嵌套出现在其它模式中, 否则会报错

1
let opt = Some(0)
2
match (opt) {
3
    case x | x => {}                // error: variable cannot be introduced in patterns connected by '|'
4
    case Some(x) | Some(x) => {}    // error: variable cannot be introduced in patterns connected by '|'
5
    case x: Int64 | x: String => {} // error: variable cannot be introduced in patterns connected by '|'
6
}

绑定模式, 就是会将 selector 的值, 绑定到定义的变量中

此变量可以在=>之后的表达式中使用, 也是会匹配任意值

如果使用绑定模式, 就无法用|尝试连接多个匹配

Tuple模式#

tuple pattern 用于匹配Tuple值, tuple pattern 定义为由圆括号括起来的多个 pattern , 每个 pattern 之间使用逗号分隔: (pattern_1, pattern_2, … pattern_k)

例如, (x, y, z)是由三个 binding pattern 组成的一个 tuple pattern , (1, 0, 0)是由三个 constant pattern 组成的一个 tuple pattern

tuple pattern 中的子 pattern 个数需要和 selector 的维度相同, 并且如果子 pattern 是 constant pattern 或 enum pattern 时, 其类型要和 selector 对应维度的类型相同

tuple 模式的语法定义为:

1
tuplePattern
2
    : '(' pattern (',' pattern)+ ')'
3
    ;

使用 tuple 模式的例子如下:

1
let scoreTuple = ("Allen", 90)
2
var scoreResult: String = match (scoreTuple) {
3
    case ("Bob", 90) =>  "Bob got 90"
4
    case ("Allen", score) =>  "Allen got ${score}" // matched
5
    case ("Allen", 100) | ("Bob", 100) =>  "Allen or Bob got 100"
6
    case (_, _) =>  ""
7
}

类型模式#

使用类型模式可以很方便地实现type check和type cast

类型模式的语法定义为:

1
typePattern
2
  : (wildcardPattern | varBindingPattern) ':' type
3
  ;

对于类型模式varBindingPattern : type(或wildcardPattern : type)

首先判断要匹配的值的运行时类型是否是:右侧type定义的类型或它的子类, 若类型匹配成功则将值的类型转换为type定义的类型, 然后将新类型的值与:左侧的varBindingPattern进行绑定(对于wildcardPattern : type, 不存在绑定)

只有类型匹配, 才算成功匹配, 否则匹配失败, 因此, varBindingPattern : type(或wildcardPattern : type)可以同时实现type test和type cast

使用类型模式匹配的例子如下:

1
open class Point {
2
    var x: Int32 = 1
3
    var y: Int32 = 2
4
    init(x: Int32, y: Int32) {
5
        this.x = x
6
        this.y = y
7
    }
8
}
9
class ColoredPoint <: Point {
10
    var color: String = "green"
11
    init(x: Int32, y: Int32, color: String) {
12
        super(x, y)
13
        this.color = color
14
    }
15
}
16

17
let normalPt = Point(5,10)
18
let colorPt = ColoredPoint(8,24,"red")
19
var rectangleArea1: Int32 = match (normalPt) {
20
    case _: Point => normalPt.x * normalPt.y  // matched
21
    case _ => 0
22
}
23
var rectangleArea2: Int32 = match (colorPt) {
24
    case cpt: Point => cpt.x * cpt.y          // matched
25
    case _ => 0
26
}

类型模式, 是根据 selector 的类型进行匹配的, 可以是通配符模式 也可以绑定模式

可以匹配 selector 的类型以及子类型, 如果是子类型且存在绑定, 则绑定的变量会变为父类型变量

enum模式#

enum模式主要和enum类型配合使用

enum pattern 用于匹配enum constructor, 格式是constructorName(无参构造器)或constructorName(pattern_1, pattern_2, ..., pattern_k)(有参构造器), 圆括号内用逗号分隔的若干 pattern (可以是其它任何类型的 pattern , 并允许嵌套)依次对每个参数进行匹配

enum模式的语法定义为:

1
enumPattern
2
   : (userType '.')? identifier enumPatternParameters?
3
   ;
4
enumPatternParameters
5
   : '(' pattern (',' pattern)* ')'
6
   ;

使用enum模式匹配的例子如下:

1
enum TimeUnit {
2
    | Year(Float32)
3
    | Month(Float32, Float32)
4
    | Day(Float32, Float32, Float32)
5
    | Hour(Float32, Float32, Float32, Float32)
6
}
7
let oneYear = TimeUnit.Year(1.0)
8
var howManyHours: Float32 = match (oneYear) {
9
    case Year(y) => y * Float32(365 * 24) // matched
10
    case Month(y, m) => y * Float32(365 * 24) + m * Float32(30 * 24)
11
    case Day(y, m, d) => y * Float32(365 * 24) + m * Float32(30 * 24) + d * Float32(24)
12
    case Hour(y, m, d, h) => y * Float32(365 * 24) + m * Float32(30 * 24) + d * Float32(24) + h
13
}
14

15
let twoYear = TimeUnit.Year(2.0)
16
var howManyYears: Float32 = match (twoYear) {
17
    case Year(y) | Month(y, m) => y // error: variable cannot be introduced in patterns connected by '|'
18
    case Year(y) | Month(x, _) => y // error: variable cannot be introduced in patterns connected by '|'
19
    case Year(y) | Month(y, _) => y // error: variable cannot be introduced in patterns connected by '|'
20
    ...
21
}

如果模式匹配所在的作用域中, 某个 pattern 中的identifier是enum构造器时, 该identifier总是会被当成 enum pattern 进行匹配, 否则才会作为 binding pattern 匹配

如果enum成员是有参数的, 模式匹配就可以匹配成员以及携带的值

但是不能通过|尝试匹配同一个enum的不同成员

如果模式匹配所在的作用域中, 某个 pattern 中的identifier是enum构造器时, 该identifier总是会被当成 enum pattern 进行匹配, 否则才会作为 binding pattern 匹配

1
enum Foo {
2
    A | B | C
3
}
4

5
func f() {
6
    let x = Foo.A
7
    match (x) {
8
        case A => 0 // enum pattern
9
        case B => 1 // enum pattern
10
        case C => 2 // enum pattern
11
        case D => 3 // binding pattern
12
    }
13
}

需要注意的是, 对enum进行匹配时, 要求 enum pattern 的类型和 selector 的类型相同, 同时编译器会检查enum类型的每个constructor(包括constructor的参数的值)是否被完全覆盖, 如果未做到全覆盖, 则编译器会报错

1
enum TimeUnit {
2
    | Year(Float32)
3
    | Month(Float32, Float32)
4
    | Day(Float32, Float32, Float32)
5
    | Hour(Float32, Float32, Float32, Float32)
6
}
7

8
let oneYear = TimeUnit.Year(1.0)
9
var howManyHours: Float32 = match (oneYear) { // error: 匹配必须全覆盖
10
    case Year(y) => y * Float32(365 * 24)
11
    case Month(y, m) => y * Float32(365 * 24) + m * Float32(30 * 24)
12
}