泛型接口#

泛型可以用来定义泛型接口，以标准库中定义的 Iterable 为例，它的成员函数 iterator 需要返回一个 Iterator 类型，这一类型是一个容器的遍历器

Iterator 是一个泛型接口，Iterator 内部有一个从容器类型中返回下一个元素的 next 成员函数，next 成员函数返回的类型是一个需要在使用时指定的类型，所以 Iterator 需要声明泛型参数

1
public interface Iterable<E> {
2
    func iterator(): Iterator<E>
3
}
4

5
public interface Iterator<E> <: Iterable<E> {
6
    func next(): Option<E>
7
}
8

9
public interface Collection<T> <: Iterable<T> {
10
     prop size: Int64
11
     func isEmpty(): Bool
12
}

泛型接口的语法是:

1
interface Inter<T> {}

依旧是使用<...>声明类型形参列表

要实现泛型接口, 也同样通过接口名<实参>构建特定类型的接口类型

泛型类#

泛型接口中介绍了泛型接口的定义和使用，本节介绍泛型类的定义和使用

如 Map 的键值对就是使用泛型类来定义的

Map 类型中的键值对 Node 类型就可以使用泛型类来定义：

1
public open class Node<K, V> where K <: Hashable & Equatable<K> {
2
    public var key: Option<K> = Option<K>.None
3
    public var value: Option<V> = Option<V>.None
4

5
    public init() {}
6

7
    public init(key: K, value: V) {
8
        this.key = Option<K>.Some(key)
9
        this.value = Option<V>.Some(value)
10
    }
11
}

由于键与值的类型有可能不相同，且可以为任意满足条件的类型，所以 Node 需要两个类型形参 K 与 V ，K <: Hashable, K <: Equatable<K> 是对于键类型的约束，意为 K 要实现 Hashable 与 Equatable<K> 接口，也就是 K 需要满足的条件

对于泛型约束，详见 泛型约束 章节

由于 泛型类的静态成员变量的内存是共享的，因此，静态成员变量 或 属性的类型声明和表达式中, 不能引用类型参数 或 包含未实例化泛型类型表达式

另外，静态变量或属性初始化表达式中不能调用泛型类的静态成员函数或属性

1
class A<T> {}
2
class B<T> {
3
    static func foo() {1}
4
    static var err1: A<T> = A<T>()        // Error, 静态成员不能依赖于泛型形参'Generics-T'
5
    static prop err2: A<T> {              // Error, 静态成员不能依赖于泛型形参'Generics-T'
6
        get() {
7
            A<T>()                        // Error, 静态成员不能依赖于泛型形参'Generics-T'
8
        }
9
    }
10
    static var vfoo = foo()               // Error, 等于'static var vfoo = B<T>.foo()'，隐式引用泛型'T'
11
    static var ok: Int64 = 1
12
}
13

14
main() {
15
    B<Int32>.ok = 2
16
    println(B<Int64>.ok) // 2
17
}

仓颉泛型类的定义并不复杂

但, 类是可以定义 静态成员变量和静态属性的

在非泛型的类中 静态成员变量是类共享的, 而 在泛型类中, 静态成员变量也是类共享的

文档中描述: 泛型类的静态成员变量的内存是共享的

这表示, 在使用泛型类时, 无论类型实参是什么, 静态成员变量都是唯一的

这就意味着, 泛型类的静态成员变量 必须与泛型形参无关

所以, 泛型类的静态成员变量和属性, 不允许引用 包含类型变元的任意表达式

除此之外, 泛型类没有其他需要特别注意的地方

泛型结构体#

struct 类型的泛型与 class 是类似的，下面可以使用 struct 定义一个类似于二元元组的类型：

1
struct Pair<T, U> {
2
    let x: T
3
    let y: U
4
    public init(a: T, b: U) {
5
        x = a
6
        y = b
7
    }
8
    public func first(): T {
9
        return x
10
    }
11
    public func second(): U {
12
        return y
13
    }
14
}
15

16
main() {
17
    var a: Pair<String, Int64> = Pair<String, Int64>("hello", 0)
18
    println(a.first())
19
    println(a.second())
20
}

程序输出的结果为：

1
hello
2
0

在Pair 中提供了 first 与 second 两个函数来取得元组的第一个与第二个元素

泛型结构体同样没有其他注意事项, 同样要注意 泛型结构体的静态成员共享的特点

泛型枚举#

在仓颉编程语言的泛型 enum 类型设计中，Option 类型是一个典型的示例，关于 Option 详细描述请参见 Option类型 章节

Option 类型用于表示在某一类型上的值可能是个空的值

这样，Option 就可以用来表示在某种类型上计算的失败

这里是何种类型上的失败是不确定的，所以很明显，Option 是一个泛型类型，需要声明类型形参

1
package std.core              // `Option` 定义在 std.core
2

3
public enum Option<T> {
4
      Some(T)
5
    | None
6

7
    public func getOrThrow(): T {
8
        match (this) {
9
            case Some(v) => v
10
            case None => throw NoneValueException()
11
        }
12
    }
13
    ...
14
}

可以看到，Option<T> 分成两种情况，一种是 Some(T)，用来表示一个有值的返回结果，另一种是 None 用来表示一个空的结果

其中的 getOrThrow 函数会是将 Some(T) 内部的值返回出来的函数，返回的结果就是 T 类型，而如果参数是 None，那么直接抛出异常

例如：如果想定义一个安全的除法，因为在除法上的计算是可能失败的

如果除数为 0，那么返回 None ，否则返回一个用 Some 包装过的结果：

1
func safeDiv(a: Int64, b: Int64): Option<Int64> {
2
    var res: Option<Int64> = match (b) {
3
                case 0 => None
4
                case _ => Some(a/b)
5
            }
6
    return res
7
}

这样，在除数为 0 时，程序运行的过程中不会因除以 0 而抛出算术运算异常

仓颉的泛型枚举, 也没有什么需要特别注意的

仓颉内置的Option类型是一个很好的例子