for-in表达式#

一个完整的 for-in表达式 具有如下形式:

1
for (p in e where c) {
2
    s
3
}

其中pattern guard``where c是非必须的, 因此更简易的 for-in表达式 具有如下形式:

1
for (p in e) {
2
    s
3
}

for-in表达式 的语法定义为:

1
forInExpression
2
    : 'for' '(' patternsMaybeIrrefutable 'in' expression patternGuard? ')' block
3
    ;
4

5
patternsMaybeIrrefutable
6
    : wildcardPattern
7
    | varBindingPattern
8
    | tuplePattern
9
    | enumPattern
10
    ;
11

12
patternGuard
13
    : 'where' expression
14
    ;

上述语法定义中, 关键字for之后只能是那些一定或可能为 irrefutable 的 pattern(见 模式的分类 )

在语义检查阶段, 会检查for之后的 pattern 是否真的是 irrefutable, 如果不是 irrefutable pattern, 则编译报错

另外, 如果for之后的 pattern 中存在 binding pattern, 相当于新声明了一个(或多个)let变量, 每个变量的作用域从它第一次出现的位置到循环体结束

for(pattern in expression patternGuard)

中要求 pattern 必须 一定或可能 irrefutable, 也就是不能总是 refutable

这意味着, for-in表达式, 允许像模式匹配那样, 匹配遍历expression中的元素

但, 必须要能够匹配expression中的所有元素?

就像这样?

1
for ((i, j) in [(1, 2), (3, 4)]) {
2
    println("Sum = ${i + j}")
3
}

从语法定义来看, 还可以通配符模式、绑定模式、枚举模式进行匹配

但都要满足 irrefutable

且, 如果存在 绑定模式, 相当于声明了新的变量, 也就可能触发遮盖:

1
let x = 20;
2
for (x in [1, 2, 3, 4, 5, 6, 7]) {
3
    println(x)
4
}
5
// for 中的 x 是绑定模式, 相当于新声明一个变量, 触发遮盖

for-in会先对expression求值, 再调用其iterator()函数, 获取一个类型为Iterator<T>的值

程序通过调用Iterator<T>的next()函数开始执行循环, 我们可以使用pattern匹配迭代的元素, 如果匹配成功(如果存在patternGuard, 也必须同时满足patternGuard的条件), 则执行循环体block, 然后在开始处重新调用next()继续循环, 当next()返回None时循环终止

Iterable<T>和Iterator<T>可在标准库中查阅

1
main(): Int64 {
2
    let intArray: Array<Int32> = [0, 1, 2, 3, 4]
3
    for (item in intArray) {
4
        print(item)          // output: 01234
5
    }
6

7
    let intRange = 0..5
8
    for (number in intRange where number > 2) {
9
        print(number)        // output: 34
10
    }
11

12
    return 0
13
}

for (pattern in expression patternGuard)

pattern 匹配的是expreesion的迭代器元素, 循环体执行完, 自动调用迭代器的next()函数, 获取迭代下一个值

while表达式#

while表达式的语法定义为:

1
whileExpression
2
    : 'while' '(' ('let' deconstructPattern '<-')? expression ')' block
3
    ;

其中while是关键字, while之后是一个小括号, 小括号内可以是一个表达式或者一个let声明的解构匹配, 接着是一个块

一个基础的while表达式举例:

1
main(): Int64 {
2
    var hundred = 0
3
    while (hundred < 100) { // until hundred = 100
4
        hundred++
5
    }
6

7
    return 0
8
}

while表达式首先对while之后的表达式进行求值(要求表达式的类型为Bool), 如果表达式的值等于true, 则执行它之后的块, 接着重新计算表达式的值并判断是否重新执行一次循环; 如果表达式的值等于false, 则终止循环

如果while()的括号内是普通Bool类型表达式, 那么就与 C/C++中的while表达式一样

如果表达式值为true, 那么就去执行循环体

不过, 仓颉中的while还有一种let解构匹配的模式

对于包含let的while表达式, 我们称之为while-let表达式

我们可以用while-let表达式来做一些简单的解构操作

一个基础的while-let表达式举例:

1
main(): Int64 {
2
    var x: Option<Int64> = Option<Int64>.Some(100)
3
    // while-let expression
4
    while (let Some(v) <- x) {
5
        print("x has value")
6
        x = ...
7
    }
8

9
    return 0
10
}

while-let表达式首先对<-之后的表达式进行求值(表达式的类型为可以是任意类型), 如果表达式的值能匹配let之后的 pattern, 则执行它之后的块, 接着重新计算表达式的值然后再次匹配并判断是否重新执行一次循环; 如果匹配失败, 则终止当前的while循环

let之后的 pattern 支持常量模式、通配符模式、绑定模式、Tuple模式、enum模式

while-let与之前的if-let是类似的(见 条件表达式 )

do-while表达式#

do-while 表达式的语法定义为:

1
doWhileExpression
2
 : 'do' block 'while' '(' expression ')'
3
 ;

与while表达式不同的是:

while表达式在第一次循环迭代时, 如果表达式expression的值为false, 则循环体不会被执行;

然而对于do-while表达式, 第一次循环迭代时, 先执行循环体block, 然后再根据表达式expression的值决定是否再次执行循环体, 也就是说do-while表达式中的循环体会至少执行一次

例如:

1
main(): Int64 {
2
 var hundred = 0
3
 do {
4
     hundred++
5
 } while (hundred < 100)
6
 return 0
7
}

循环表达式总结#

for-in、while和do-while这三种循环表达式的表达能力是等价的

通常, 在知道循环的次数或遍历一个序列中的所有元素时使用for-in表达式;

在不知道循环的次数, 但知道循环终止条件时使用while或do-while表达式

三种循环表达式的类型均为Unit

由于break、continue表达式必须有包围着它们的循环体, 所以对于三种循环表达式, 其循环条件中出现的break或continue均会绑定到其最近的外层循环;

如外层不存在循环, 则报错

例如:

1
while (true) {
2
    println("outer") // printed once
3
    do {
4
        println("inner") // printed once
5
    } while (break)  // stop the execution of the outer loop
6
    println("unreached") // not printed
7
}

break表达式#

break表达式只能出现在循环表达式的循环体中, 并将程序的执行权交给被终止循环表达式之后的表达式

例如, 下面的代码通过在while循环体内使用break表达式, 实现在区间[1, 49]内计算4和6的最小公倍数

1
main(): Int64 {
2
    var index: Int32 = 0
3
    while (index < 50) {
4
        index = index + 1
5
        if ((index % 4 == 0) && (index % 6 == 0)) {
6
            print("${index} is divisible by both 4 and 6") // output: 12
7
            break
8
        }
9
    }
10
    return 0
11
}

需要注意的是, 当break出现在嵌套的循环表达式中时, 只能终止直接包围它的循环表达式, 外层的循环并不会受影响

例如, 下面的程序将输出 5 次12 is divisible by both 4 and 6, 且每次同时会输出i的值:

1
main(): Int64 {
2
    var index: Int64 = 0
3
    for (i in 0..5) {
4
        index = i
5
        while (index < 20) {
6
            index = index + 1
7
            if ((index % 4 == 0) && (index % 6 == 0)) {
8
                print("${index} is divisible by both 4 and 6")
9
                break
10
            }
11
        }
12
        print("${i}th test")
13
    }
14
    return 0
15
}

仓颉的break用法基本与 C/C++中break在循环体中的用法是一致的

只能跳出所在层的循环, 对更外层循环无用

continue表达式#

continue表达式只能出现在循环表达式的循环体中, 用于提前结束离它最近循环表达式的当前迭代, 然后开始新一轮的循环(并不会终止循环表达式)

例如, 下面的代码输出区间[1,49]内所有可以同时被4和6整除的数(12、24、36、48), 对于其他不满足要求的数, 同样会显式地输出

1
main(): Int64 {
2
    var index: Int32 = 0
3
    while (index < 50) {
4
        index = index + 1
5
        if ((index % 4 == 0) && (index % 6 == 0)) {
6
            print("${index} is divisible by both 4 and 6")
7
            continue
8
        }
9
        print("${index} is not what we want")
10
    }
11
    return 0
12
}

continue的用法, 也基本与 C/C++一致

return表达式#

return表达式只能出现在函数体中, 它可以在任意位置终止函数的执行并返回, 实现控制流从被调用函数到调用函数的转移

return表达式有两种形式:return和return expr(expr是一个表达式)

• 若为return expr的形式, 我们将expr的值作为函数的返回值, 所以要求expr的类型与函数定义中的返回类型保持一致

  1
  // return expression
  2
  func larger(a: Int32, b: Int32): Int32 {
  3
      if (a >= b) {
  4
          return a
  5
      } else {
  6
          return b
  7
      }
  8
  }
  

• 若为return的形式, 我们将其视为return ()的语法糖, 所以要求函数的返回类型也为Unit

  1
  // return expression
  2
  func equal(a: Int32, b: Int32): Unit {
  3
      if (a == b) {
  4
          print("a is equal to b")
  5
          return
  6
      } else {
  7
          print("a is not equal to b")
  8
      }
  9
  }
  

需要说明的是, return表达式作为一个整体, 其类型并不由后面跟随的表达式决定(return后面跟随的表达式为()), 而是Nothing类型

return的用法, 也基本与 C/C++保持一致

但, 仓颉中return拥有具体类型:Nothing. 且恒为Nothing

return是return ()的语法糖, 就像 C/C++中, 如果函数返回值类型为void, 可以不使用return, 也可以执行return;

throw表达式#

throw表达式用于抛出异常, 在调用包含throw表达式的代码块时, 如果throw表达式被执行到, 就会抛出相应的异常, 并由事先定义好的异常处理逻辑进行捕获和处理, 从而改变程序的执行流程

下面的例子中, 当除数为 0 时, 抛出算术异常:

1
func div(a: Int32, b: Int32): Int32 {
2
    if (b != 0) {
3
        return a / b
4
    } else {
5
        throw ArithmeticException()
6
    }
7
}

关于return和throw表达式, 本节只做了最简单的使用举例, 有关它们的详细介绍, 请分别参见函数和异常章节

如果没有了解过任何编程语言, 要深入理解还是要参阅具体的文档

成员访问表达式#

成员访问表达式的语法定义为上述后缀表达式语法的第 3 条:

1
postfixExpression '.' identifier typeArguments?

成员访问表达式可以用于访问class、interface、struct等的成员

果然, 成员访问表达式 即为 类、接口、结构体访问成员的表达式

成员访问表达式的形式为T.a

T可以表示为特定的实例或类型名, 我们将其称为成员访问表达式的主体

a表示成员的名字

• 如果T是类的实例化对象, 通过这种方式可以访问类或接口中的非静态成员
• 如果T是struct的实例, 允许通过实例名访问struct内的非静态成员
• 如果T是类名、接口名或struct名, 允许直接通过类型名访问其静态成员

需要注意的是: 类、接口和struct的静态成员的访问主体只能是类型名

• T是this: 在类或接口的作用域内, 可以通过this关键字访问非静态成员
• T是super: 在类或接口作用域内, 可以通过super关键字访问当前类对象直接父类的非静态成员

C/C++中因为存在值和指针, 所以有两种访问成员的方式.和->

不过, 仓颉中统一通过.访问成员

要注意: 仓颉中静态成员, 只能通过类型名访问, 不能通过具体实例访问

this和super只能在类或接口内部通过.访问非静态成员

对于成员访问表达式e.a, 如果e是类型名:

• 当a是e的可变静态成员变量时, e.a是可变的, 其他情况下e.a是不可变的

如果e是表达式(假设e的类型是T):

• 当T是引用类型时, 如果a是T的可变成员变量, 则e.a是可变的, 否则e.a是不可变的;
• 当T是值类型时, 如果e可变且a是T的可变成员变量, 则e.a是可变的, 否则e.a是不可变的

仓颉通过类型只能访问静态成员, 通过实例只能访问非静态成员

仓颉中的不可变成员, 无论什么时候都不可变

仓颉中的可变成员, 引用类型都可变, 值类型只有实例时可变时, 成员才可变

函数调用表达式#

函数调用表达式的语法定义为上述后缀表达式语法的第 4 条, 其中callSuffix和valueArgument的语法定义为:

1
callSuffix
2
    : '(' (valueArgument (',' valueArgument)*)? ')'
3
    ;
4

5
valueArgument
6
    : identifier ':' expression
7
    | expression
8
    | refTransferExpression
9
    ;
10

11
refTransferExpression
12
    : 'inout' (expression '.')? identifier
13
    ;

函数调用表达式用于调用函数, 函数详见第 5 章

对于函数调用表达式f(x), 假设f的类型是T

如果T是函数类型, 则调用名为f的函数, 否则, 如果T重载了函数调用操作符(), 则f(x)会调用其()操作符重载函数(参见 [可以被重载的操作符])

函数调用的后缀是(), 可加参数可不加参数

加参数可以指定形参进行传参:func1(param1: 1, param2: 2), 不过只适用于函数定义时的命名参数, 且命名参数只能命名传参

非命名参数就只能非命名传参

refTransferExpression意思是引用传参? 应该与 C++中的引用传参一样, 可以通过形参直接访问实参(具体还要阅读到函数章节再了解)

索引访问表达式#

索引访问表达式的语法定义为上述后缀表达式语法的第 5 条, 其中indexAccess的语法定义为:

1
indexAccess
2
    : '[' (expression | rangeElement) ']'
3
    ;
4

5
rangeElement
6
    :  '..'
7
    | ('..=' | '..' ) expression
8
    | expression '..'
9
    ;

索引访问表达式用于那些支持索引访问的类型(包括Array类型和Tuple类型)通过下标来访问其具体位置的元素, 详见第 2 章中关于 Array类型 和 Tuple类型 的介绍

对于索引访问表达式e[a](假设e的类型是T):

• 当T是元组类型时, e[a]是不可变的;
• 当T不是元组类型时, 如果T重载了 set 形式的操作符[](参见 [可以被重载的操作符]), 则e[a]是可变的, 否则e[a]是不可变的

对于索引访问表达式e1[e2], 仓颉语言总是先求值e1至v1, 再将e2求值至v2, 最后根据下标v2选取对应的值或调用相应的重载了的[]操作符

记得在阅读Tuple类型介绍时, 文档中提到使用[]访问元组的元素, []里只能是Int64类型字面量, 应该不能是Range

问号操作符#

问号操作符?为一元后缀操作符, 它必须和上文介绍的后缀操作符., (), {}或[]一起使用(出现在后缀操作符之前), 实现Option类型对这些后缀操作符的支持, 例如:a?.b, a?(b), a?[b]等等

其中()是函数调用, 当函数调用最后一个实参是lambda时, 可以使用尾闭包语法a?{b}

将包含?.、?()、?{}或?[]的表达式称为 optional chaining 表达式

optional chaining 表达式的语法定义为上述后缀表达式语法的最后一条, 其中questSeperatedItems的语法定义为:

1
questSeperatedItems
2
    : questSeperatedItem+
3
    ;
4

5
questSeperatedItem
6
    : itemAfterQuest (callSuffix | callSuffix? trailingLambdaExpression | indexAccess)?
7
    ;
8

9
itemAfterQuest
10
    : '.' identifier typeArguments?
11
    | callSuffix
12
    | indexAccess
13
    | trailingLambdaExpression
14
    ;

关于 optional chaining 表达式, 规定:

1. 对于表达式e, 将e中的所有?删除, 并且将紧邻?之前的表达式的类型由Option<T>替换为T之后, 得到表达式e1

   如果e1的类型是Option类型, 则在e之后使用.、()、{}或[]时, 需要在e和这些操作符之间加上?; 否则, 不应该加?

2. Optional chaining 表达式的类型是Option<T>(即无论其中有几个?, 类型都只有一层Option), 类型T为 optional chaining 中最后一个表达式(变量或函数名、函数调用表达式、下标访问表达式)的类型

3. 一旦 optional chaining 中的某个Option类型的表达式的值为None, 则整个 optional chaining 表达式的值为None

   如果 optional chaining 中每个Option类型的表达式的值都等于某个Some值, 则整个表达式的值为Some(v)(v的类型是最后一个表达式的类型)

解释一下这部分文档内容

?问号操作符实际是作用于Option类型的

即, 如果存在一个变量e的类型是Option<T>类型的, 就可以使用e?.、e?()、e?{}、e?[]来尝试访问成员、调用函数、调用lambda、通过索引访问数据

?之后的操作符, 是根据Option<T>中 这个实际的T决定的, T是类、结构体、interface就用., 是函数就用(), 是lambda就可以用尾闭包{}, 是数组、元组等就可以用[]

?操作符, 通过Option类型, 来安全判断None的情况, 你的Option<T>数据如果是None, 使用?就会取值None, 并终止之后的操作, 整个表达式值就是None. 这对应文档中, 规则 3 上半部分:

一旦 Optional chaining 中的某个 Option 类型的表达式的值为None, 则整个 Optional chaining 表达式的值为None

比如:

1
class Test {
2
    let value = 20
3
}
4

5
func getTest(number: Int64) : Option<Test> {
6
    if (number == 20) {
7
        return Test()
8
    }
9

10
    return None
11
}
12

13
main(): Int64 {
14
    let res = getTest(20)
15
    println(res?.value)
16
    // println(res.value)
17

18
    return 0
19
}

如果尝试不用?访问成员, 是会报错的, 因为res是Option类型的, 可能是None, 直接访问成员是不安全的

这段代码的执行结果为:

这个结果也对应文档中的规则 3 的下半部分:

如果 optional chaining 中每个 Option 类型的表达式的值都等于某个Some值, 则整个表达式的值为Some(v)(v的类型是最后一个表达式的类型)

即, 如果一个完整的 Optional chaining, 链中不存在None, 那么最终结果就是Some(value), value是最终结果的实际类型的数据

其次, 无论 Optional chaining 有多长, 最终的结果也就只有一层Option, 即a?.b?.c?[2]?()也就只有一层Option, 不是None就是Some(value). 这是规则 2 的内容

但是对于规则 1, 不是很理解. 因为按照规则 3, Optional chaining 的最终结果一定是Option类型, 如果访问成员或调用函数是一定要加?的, 但规则 1 说有另外的判断

规则 1 的意思容易理解为 要根据最终Some(value), value的实际类型来判断是否需要再加?, 但是从实际情况来看无论value是什么类型, 最终 Optional chaining 的结果是一定要加?的

但是经过不断地测试和验证, 规则 1 针对的不是一个完整的 Optional chaining

规则 1 针对的应该是一个 Optional chaining 的中间过程, 即 如果一个 Optional chaining 很长, 那么并不是所有的成员访问都需要加?的

可能存在a?.b?.c?.d, 也可能存在a?.b?.c.d, 规则 1 针对的是类似这种情况, 在 Optional chaining 的过程中, 如果出现访问到的某个元素是非Option类型的, 那么要用此元素访问其成员或调用函数等操作, 不需要加?, 但最终整个 Optional chaining 是Option类型的

类似:

1
class BaseTest {
2
    let value: Int64 = 10
3
}
4

5
class Test {
6
    let value: Int64 = 20
7
    let base = BaseTest()
8
}
9

10
func getTest(number: Int64) : Option<Test> {
11
    if (number == 20) {
12
        return Test()
13
    }
14

15
    return None
16
}
17

18
main(): Int64 {
19
    let res = getTest(20)
20
    println(res?.base.value)
21

22
    return 0
23
}

过程中访问到res的成员base, base是非Option类型的, 所以不加?访问其成员

但整个 Optional chaining 的最终类型就是Option类型

以表达式a?.b, c?(d)和e?[f]为例, 说明如下:

1. 表达式a的类型需要是某个Option<T1>且T1包含实例成员b

   表达式c的类型需要是某个Option<(T2)->U2>且d的类型为T2

   表达式e的类型需要是某个Option<T3>且T3支持下标操作符

2. 表达式a?.b, c?(d)和e?[f]的类型分别为Option<U1>, Option<U2>和Option<U3>, 其中U1是T1中实例成员b的类型, U2是函数类型(T2)->U2的返回值类型, U3是T3执行下标操作的返回类型

3. 当a, c和e的值分别等于Some(v1), Some(v2)和Some(v3)时, a?.b, c?(d)和e?[f]的值分别等于Option<U1>.Some(v1.b), Option<U2>.Some(v2(d))和Option<U3>.Some(v3[f])

   当a, c和e的值分别等于None时, a?.b, c?(d)和e?[f]的值分别等于Option<U1>.None, Option<U2>.None和Option<U3>.None(注意这里的b, d和f都不会被求值)

事实上, 表达式a?.b, c?(d)和e?[f]分别等价于如下match表达式:

1
// a?.b 等同于以下匹配表达式
2
match (a) {
3
    case Some(v) => Some(v.b)
4
    case None => None<U1>
5
}
6

7
// c?(d) 等同于以下匹配表达式
8
match (c) {
9
    case Some(v) => Some(v(d))
10
    case None => None<U2>
11
}
12

13
// e?[f] 等同于以下匹配表达式
14
match (e) {
15
    case Some(v) => Some(v[f])
16
    case None => None<U3>
17
}

即, 对于a?.b、c?(d)或e?[f], 只要a、c、e不是None, 那么最终结果就是Some(a.b)、Some(c(d))或Some(e[f])

结果的最终类型是根据最终Some(value)中value的类型决定的, Option<T>中T即为value的实际类型

再来看一个包含多个?的多层访问的例子a?.b.c?.d(以?.为例, 其他操作类似, 不再赘述):

1. 表达式a的类型需要是某个Option<Ta>且Ta包含实例成员b, b的类型中包含实例成员变量c且c的类型是某个Option<Tc>, Tc包含实例成员d

2. 表达式a?.b.c?.d的类型为Option<Td>, 其中Td是Tc的实例成员d的类型;

3. 当a的值等于Some(va)且va.b.c的值等于Some(vc)时, a?.b.c?.d的值等于Option<Td>.Some(vc.d)

   当a的值等于Some(va)且va.b.c的值等于None时, a?.b.c?.d的值等于Option<Td>.None(d不会被求值)

   当a的值等于None时, a?.b.c?.d的值等于Option<Td>.None(b, c和d都不会被求值)

表达式a?.b.c?.d等价于如下match表达式:

1
// a?.b.c?.d 等同于以下匹配表达式
2
match (a) {
3
    case Some(va) =>
4
        let x = va.b.c
5
        match (x) {
6
            case Some(vc) => Some(vc.d)
7
            case None => None<Td>
8
        }
9
    case None =>
10
        None<Td>
11
}

这个例子中的b的类型就是非Option类型

Optional chaining 也可以作为左值表达式(参见 [赋值表达式]), 例如a?.b = e1, a?[b] = e2, a?.b.c?.d = e3等

赋值表达式的左侧是 Optional chaining 表达式时, 要求 Optional chaining 表达式是可变的(参见 [赋值表达式])

因为函数类型是不可变的, 所以只需要考虑?.和?[]这两种情况, 并且它们都可以归纳到a?.b = c和a?[b] = c这两种基本的场景(假设a的类型为Option<T>), 规定:

• 对于a?.b, 仅当T是引用类型且b可变时, a?.b是可变的, 其他情况下a?.b是不可变的
• 对于a?[b], 仅当T是引用类型且重载了 set 形式的操作符[]时, a?[b]是可变的, 其他情况下a?[b]是不可变的

当a?.b(或a?[b])可变时, 如果a的值等于Option<T>.Some(v), 将c的值赋值给v.b(或v[b])

如果a的值等于Option<T>.None, 什么也不做(b和c也不会被求值)

类似地, 表达式a?.b = e1, a?[b] = e2和a?.b.c?.d = e3分别等价于如下match表达式

1
// a?.b = e1 等同于以下匹配表达式
2
match (a) {
3
    case Some(v) => v.b = e1
4
    case None => ()
5
}
6

7
// a?[b] = e2 等同于以下匹配表达式
8
match (a) {
9
    case Some(v) => v[b] = e2
10
    case None => ()
11
}
12

13
// a?.b.c?.d = e3 等同于以下匹配表达式
14
match (a) {
15
    case Some(va) =>
16
        match (va.b.c) {
17
            case Some(vc) => vc.d = e3
18
            case None => ()
19
        }
20
    case None =>
21
        ()
22
}

Option chaining 可以当作左值被赋值, 且仅当最后一部分访问符(.或[])前的变量实际是引用类型, 且成员可变或重载set()时, 才能当作左值被赋值

因为从给的例子来看:

1
// a?.b.c?.d = e3 等同于以下匹配表达式
2
match (a) {
3
    case Some(va) =>
4
        match (va.b.c) {
5
            case Some(vc) => vc.d = e3
6
            case None => ()
7
        }
8
    case None =>
9
        ()
10
}

模式匹配表达式, 中间是直接匹配的va.b.c, 没有其他额外的规则, 只要匹配到了, 即只要最终c是引用类型, 且c.d是可变的就可以进行赋值

下面几个例子, 可以很好的说明, 可以测试一下:

1
// 全都为引用类型
2
class C {
3
    var d = 20
4
}
5

6
class B {
7
    let value: Int64 = 10
8
    let c = Some(C())
9
}
10

11
class A {
12
    let b = B()
13
}
14

15
main(): Int64 {
16
    let a = Some(A())
17
    a?.b.c?.d = 30
18
    println(a?.b.c?.d)
19

20
    return 0
21
}
22

23
// 只有最后一部分为引用类型
24
class C {
25
    var d = 20
26
}
27

28
struct B {
29
    let value: Int64 = 10
30
    let c = Some(C())
31
}
32

33
struct A {
34
    let b = B()
35
}
36

37
main(): Int64 {
38
    let a = Some(A())
39
    a?.b.c?.d = 30
40
    println(a?.b.c?.d)
41

42
    return 0
43
}
44

45
// 最后一部分不为引用类型
46
struct C {
47
    var d = 20
48
}
49

50
class B {
51
    let value: Int64 = 10
52
    let c = Some(C())
53
}
54

55
class A {
56
    let b = B()
57
}
58

59
main(): Int64 {
60
    let a = Some(A())
61
    a?.b.c?.d = 30
62
    println(a?.b.c?.d)
63

64
    return 0
65
}

最后一个例子是编译不过的, 前两个可以:

操作符?应用举例:

1
// ?. 用法
2
class C {
3
    var item: Int64 = 100
4
}
5
let c = C()
6
let c1 = Option<C>.Some(c)
7
let c2 = Option<C>.None
8
let r1 = c1?.item              // r1 = Option<Int64>.Some(100)
9
let r2 = c2?.item              // r2 = Option<Int64>.None
10
func test1() {
11
    c1?.item = 200             // c.item = 200
12
    c2?.item = 300             // no effect
13
}
14

15
// ?() 用法
16
let foo = {i: Int64 => i + 1}
17
let f1 = Option<(Int64) -> Int64>.Some(foo)
18
let f2 = Option<(Int64) -> Int64>.None
19
let r3 = f1?(1)               // r3 = Option<Int64>.Some(2)
20
let r4 = f2?(1)               // r4 = Option<Int64>.None
21

22
// ?[] 对于元组访问的用法
23
let tuple = (1, 2, 3)
24
let t1 = Option<(Int64, Int64, Int64)>.Some(tuple)
25
let t2 = Option<(Int64, Int64, Int64)>.None
26
let r7 = t1?[0]               // r7 = Option<Int64>.Some(1)
27
let r8 = t2?[0]               // r8 = Option<Int64>.None
28
func test3() {
29
    t1?[0] = 10               // error: 't1?[0]' is immutable
30
    t2?[1] = 20               // error: 't2?[0]' is immutable
31
}