扩展语法#

一个简单的扩展示例如下:

1
extend String {
2
    func printSize() {
3
        print(this.size)
4
    }
5
}
6

7
"123".printSize()         // 3

扩展定义的语法如下:

1
extendDefinition
2
    : 'extend' extendType
3
      ('<:' superInterfaces)? genericConstraints?
4
      extendBody
5
    ;
6

7
extendType
8
    : (typeParameters)? (identifier NL* DOT  NL*)* identifier (NL* typeArguments)?
9
    | INT8
10
    | INT16
11
    | INT32
12
    | INT64
13
    | INTNATIVE
14
    | UINT8
15
    | UINT16
16
    | UINT32
17
    | UINT64
18
    | UINTNATIVE
19
    | FLOAT16
20
    | FLOAT32
21
    | FLOAT64
22
    | CHAR
23
    | BOOLEAN
24
    | NOTHING
25
    | UNIT
26
    ;
27

28
extendBody
29
    : '{' extendMemberDeclaration* '}'
30
    ;
31

32
extendMemberDeclaration
33
    : (functionDefinition
34
    | operatorFunctionDefinition
35
    | propertyDefinition
36
    | macroExpression
37
    ) end*
38
    ;

扩展的定义使用extend关键字, 扩展定义依次为extend关键字、可选的泛型形参、被扩展的类型、可选的实现接口、可选的泛型约束, 以及扩展体的定义

扩展体的定义不允许省略{}

扩展只能定义在top level

扩展分为直接扩展和接口扩展两种用法, 直接扩展不需要声明额外的接口

扩展的关键字是extend, 之后要跟被扩展的类型名, 然后就类似类的定义

但要按照扩展要求进行实现

扩展的成员#

扩展的成员包括: 静态成员函数、实例成员函数、静态成员属性、实例成员属性、操作符重载函数

基本都是函数和属性, 不能扩展变量字段等

泛型扩展#

如果被扩展的类型是泛型类型, 有两种扩展语法可以对泛型类型扩展功能

一种是上面介绍的非泛型扩展

对于泛型类型, 非泛型扩展可以针对特定的 泛型实例化类型 进行扩展

在extend后允许是一个任意实例化完全的泛型类型

为这些类型增加的功能只有在类型完全匹配时才能使用

1
extend Array<String> {}   // ok
2
extend Array<Int> {}      // ok

在扩展中, 泛型类型的类型实参 必须符合 泛型类型定义处的约束要求, 否则会编译报错

1
class Foo<T> where T <: ToString {}
2

3
extend Foo<Int64> {}                  // ok
4

5
class Bar {}
6
extend Foo<Bar> {}                    // error

被扩展类型是泛型类型时, 如果扩展时指定所有的类型参数, 那么扩展方式就与上面介绍的方式保持一致

另一种是在extend后面引入泛型形参的泛型扩展

泛型扩展可以用来扩展 未实例化 或 未完全实例化 的泛型类型

在extend后允许声明泛型形参, 这些泛型形参必须被 直接或间接 使用在被扩展的泛型类型上

为这些类型增加的功能只有在 类型和约束完全匹配 时才能使用

1
extend<T> Array<T> {}                     // ok

泛型扩展引入的泛型变元必须在被扩展类型中使用, 否则报未使用错误

1
extend<T> Array<T> {}                 // ok
2
extend<T> Array<Option<T>> {}         // ok
3
extend<T> Array<Int64> {}             // error
4
extend<T> Int64 <: Equatable<T> {     // error
5
    ...
6
}

如果被扩展类型未指定或未指定所有类型参数, 那么扩展语法就为:extend<T> Array<T> {}

要求extend<T>中的T, 必须要在被扩展类型中使用

不管是泛型扩展还是非泛型扩展, 对泛型类型扩展都不能重定义成员和重复实现接口

当泛型扩展的泛型变元被直接使用在被扩展类型的类型实参时, 对应的泛型变元会隐式引入被扩展类型定义时的泛型约束

1
class Foo<T> where T <: ToString {}
2

3
extend<T> Foo<T> {}                   // 隐式引入 T <: ToString

泛型扩展引入的泛型形参不能用于被扩展类型或被实现的接口, 否则会编译报错

1
extend<T> T {} // error
2
extend<T> Unit <: T {} // error

我们可以在泛型扩展中使用 额外的泛型约束

通过这种方式添加的成员或接口, 只有当该类型的实例在 满足 扩展的泛型约束 时才可以使用, 否则会报错

1
class Foo<T> {
2
    var item: T
3
    init(it: T) {
4
        item = it
5
    }
6
}
7

8
interface Eq<T> {
9
    func equals(other: T): Bool
10
}
11

12
extend<T> Foo<T> <: Eq<Foo<T>> where T <: Eq<T> {
13
    public func equals(other: Foo<T>) {
14
        item.equals(other.item)
15
    }
16
}
17

18
class A {}
19
class B <: Eq<B> {
20
    public func equals(other: B) { true }
21
}
22

23
main() {
24
    let a = Foo(A())
25
    a.equals(a)                       // error, A 尚未实现 Eq
26
    let b = Foo(B())
27
    b.equals(b)                       // ok, B 实现了 Eq
28
}

泛型类型不能重复实现同一接口

对于同一个泛型类型, 无论它是否完全实例化, 都不能重复实现同一接口

如果重复实现会在编译时报错

1
interface I {}
2
extend Array<String> <: I {}              // error, 不能重复实现同一个接口
3
extend<T> Array<T> <: I {}                // error, 不能重复实现同一个接口
4

5
interface Bar<T> {}
6
extend Array<String> <: Bar<String> {}    // error, 不能重复实现同一个接口
7
extend<T> Array<T> <: Bar<T> {}           // error, 不能重复实现同一个接口

对于同一个泛型类型, 无论它是否完全实例化, 都不能定义相同类型或相同签名的成员

如果重复定义会在编译时报错

1
// case 1
2
extend Array<String> {
3
    func f() {}                           // error, 不能重复定义
4
}
5
extend<T> Array<T> {
6
    func f() {}                           // error, 不能重复定义
7
}
8

9
// case 2
10
extend Array<String> {
11
    func g(a: String) {}                  // error, 不能重复定义
12
}
13
extend<T> Array<T> {
14
    func g(a: T) {}                       // error, 不能重复定义
15
}
16

17
// case 3
18
extend<T> Array<T> where T <: Int {
19
    func g(a: T) {}                       // error, 不能重复定义
20
}
21
extend<V> Array<V> where V <: String {
22
    func g(a: V) {}                       // error, 不能重复定义
23
}
24

25
// case 4
26
extend Array<Int>  {
27
    func g(a: Int) {}                     // ok
28
}
29
extend Array<String>  {
30
    func g(a: String) {}                  // ok
31
}

泛型扩展, 会自动引入 泛型类型的类型约束, 且可以额外添加约束

泛型扩展, 对于同一个泛型类型, 无论它是否完全实例化 都不能重复扩展同一接口, 更不能出现扩展函数重复定义的情况

这里的实例化, 指 类型参数

扩展的访问和遮盖#

扩展的实例成员与类型定义处一样可以使用this, this的含义与类型定义中的保持一致

同样也可以省略this访问成员

扩展的实例成员不能使用super

1
class A {
2
    var v = 0
3
}
4

5
extend A {
6
    func f() {
7
        print(this.v)         // ok
8
        print(v)              // ok
9
    }
10
}

扩展的实例成员可以使用this, 但不能使用super

扩展不能访问被扩展类型的private成员, 其它修饰符修饰的成员遵循可见性原则

1
class A {
2
    private var v1 = 0
3
    protected var v2 = 0
4
}
5

6
extend A {
7
    func f() {
8
        print(v1)             // error
9
        print(v2)             // ok
10
    }
11
}

扩展不允许遮盖被扩展类型的任何成员

1
class A {
2
    func f() {}
3
}
4

5
extend A {
6
    func f() {}               // error
7
}

扩展也不允许遮盖被扩展类型的其它扩展中已增加的任何成员

1
class A {}
2

3
extend A {
4
    func f() {}
5
}
6

7
extend A {
8
    func f() {}               // error
9
}

在同一个package内对同一类型可以扩展任意多次

扩展不允许出现遮盖, 其实也是不会出现遮盖情况, 因为扩展的成员看作与原类型成员同一作用域层级

在扩展中可以直接使用(不加任何前缀修饰)其它对同一类型的扩展中的非private修饰的成员

1
class Foo {}
2

3
extend Foo {                  // OK
4
    private func f() {}
5
    func g() {}
6
}
7

8
extend Foo {                  // OK
9
    func h() {
10
        g()                   // OK
11
        f()                   // Error
12
    }
13
}

扩展泛型类型时, 可以使用额外的泛型约束

泛型类型的扩展中能否直接使用其它对同一类型的扩展中的成员, 除了满足上述可访问性规则之外, 还需要满足以下约束规则:

• 如果两个扩展的约束相同, 则两个扩展中可以直接使用对方的成员

• 如果两个扩展的约束不同, 且两个扩展的约束有包含关系, 约束更严格的扩展 中可以直接使用 约束更宽松的扩展 中的成员, 反之, 则不可直接使用

• 当两个扩展的约束不同时, 且两个约束不存在包含关系, 则两个扩展中 不可以直接使用对方的成员

示例: 假设对同一个类型E<X>的两个扩展分别为扩展 1 和扩展 2 , X的约束在扩展 1 中比扩展 2 中更严格, 那扩展 1 中可直接使用扩展2中的成员, 反之, 扩展 2 中不可直接使用扩展 1的成员

1
// B <: A
2
class E<X> {}
3

4
interface I1 {
5
    func f1(): Unit
6
}
7
interface I2 {
8
    func f2(): Unit
9
}
10

11
extend<X> E<X> <: I1 where X <: B {       // 扩展 1
12
    public func f1(): Unit {
13
        f2()                              // OK
14
    }
15
}
16

17
extend<X> E<X> <: I2 where X <: A   {     // 扩展 2
18
    public func f2(): Unit {
19
        f1()                              // Error
20
    }
21
}

非泛型扩展可以直接使用其他扩展中的非private成员

而泛型扩展, 因为可能存在类型约束, 所以各扩展成员之间的调用遵循一定的限制

扩展的继承#

如果被扩展的类型是 class, 那么扩展的成员会被子类继承

1
open class A {}
2

3
extend A {
4
    func f() {}
5
}
6

7
class B <: A {
8
    func g() {
9
        f()               // ok
10
    }
11
}
12

13
main() {
14
    let x = B()
15
    x.f()                 // ok
16
}

需要注意的是, 如果在父类中扩展了成员, 由于继承规则限制, 子类中就无法再定义同名成员, 同时也无法覆盖或重新实现(允许函数重载)

1
open class A {}
2

3
extend A {
4
    func f() {}
5
    func g() {}
6
}
7

8
class B <: A {
9
    func f() {}               // error
10
    override func g() {}      // error
11
}

如果在同包内对同一个类型分别扩展实现父接口和子接口, 那么编译器会先检查实现父接口的扩展, 然后再检查实现子接口的扩展

1
class Foo {}
2

3
interface I1 {
4
   func f() {}
5
}
6
interface I2 <: I1 {
7
   func g() {}
8
}
9

10
extend Foo <: I1 {}           // first check
11
extend Foo <: I2 {}           // second check

如果是对class类型的扩展, 那么扩展成员会被继承

但是不能被覆盖、重新实现, 因为扩展成员禁止被open修饰

对同一个类型进行扩展时, 如果 分别扩展实现存在继承关系的接口, 那么 会先检查父接口的函数, 完毕之后再检查子接口的函数

这样可以保证如果子接口覆盖了父接口的成员, 最终扩展实现 会采取子接口的成员

扩展的导入与导出#

extend前不允许有修饰符, 扩展只能与被扩展类型或接口一起导入导出

这个意思应该时, 不能单独导入或导出扩展, 而是扩展之后 导入或导出 被扩展的类型或接口

导入扩展#

扩展会与被扩展的类型和扩展实现的接口一起被导入, 不能指定导入扩展

1
package pkg1
2
public class Foo {}
3

4
extend Foo {
5
    public func f() {}
6
}
7

8
///////
9

10
package pkg2
11
import pkg1.Foo               // import Foo
12

13
main() {
14
    let a = Foo()
15
    a.f()                     // ok
16
}

特别的, 由于扩展不支持遮盖任何被扩展类型的成员, 当导入的扩展发生重定义时将会报错

1
package pkg1
2
public class Foo {}
3

4
///////
5

6
package pkg2
7
import pkg1.Foo
8

9
public interface I1 {
10
    func f(): Unit {}
11
}
12

13
extend Foo <: I1 {}           // ok, 可外部访问
14

15
///////
16

17
package pkg3
18
import pkg1.Foo
19

20
public interface I2 {
21
    func f(): Unit {}
22
}
23

24
extend Foo <: I2 {}           // ok, 可外部访问
25

26
///////
27

28
package pkg4
29
import pkg1.Foo
30
import pkg2.I1                // error
31
import pkg3.I2                // error

最后一个例子, 当在pkg4中导入pkg1.Foo并同时导入pkg2.I1和pkg3.I2时, 会报错, 禁止遮蔽

从此例中可以得到一个关于接口扩展的语法规则:

当 在接口定义的包中 进行接口扩展时, 完成的扩展默认只能在接口的包中使用

即, 假设包pkg1中存在class Foo, 包pkg2中存在interface I1, 包pkg3中存在interface I2

如果在接口所在的包中, 对Foo进行接口扩展, 那么在其他包中导入Foo时, Foo的扩展并不能直接使用, 而是要 将需要使用的接口扩展的 接口 也导入到包中

即, 至少 被扩展类型、所扩展的接口 同时被导入, 才能访问对应的扩展成员