基于华为开发者空间，仓颉之泛型和扩展的神奇天地

1 概述

1.1 背景介绍

仓颉编程语言作为一款面向全场景应用开发的现代编程语言，通过现代语言特性的集成、全方位的编译优化和运行时实现、以及开箱即用的 IDE工具链支持，为开发者打造友好开发体验和卓越程序性能。

案例结合代码体验，帮助大家更直观的了解仓颉语言泛型和扩展知识。

1.2 适用对象

• 个人开发者
• 高校学生

1.3 案例时间

本案例总时长预计30分钟。

1.4 案例流程

说明：

① 进入华为开发者空间，登录云主机；
② 使用CodeArts IDE for Cangjie编程和运行仓颉代码。

1.5 资源总览

资源名称	规格	单价（元）	时长（分钟）
开发者空间 - 云主机	鲲鹏通用计算增强型 kc2 | 4vCPUs | 8G | Ubuntu	免费	30

最新案例动态，请查阅 仓颉之泛型和扩展的神奇天地 。小伙伴快来领取华为开发者空间，进入云主机桌面版实操吧！

2 环境准备

2.1 开发者空间配置

面向广大开发者群体，华为开发者空间提供一个随时访问的“开发桌面云主机”、丰富的“预配置工具集合”和灵活使用的“场景化资源池”，开发者开箱即用，快速体验华为根技术和资源。

领取云主机后可以直接进入华为开发者空间工作台界面，点击进入桌面连接云主机。没有领取在开发者空间根据指引领取配置云主机即可，云主机配置参考1.5资源总览。

点击桌面CodeArts IDE for Cangjie，打开编辑器，点击新建工程，名称demo，其他保持默认配置，点击创建。

产物类型说明：

• executable，可执行文件；
• static，静态库，是一组预先编译好的目标文件的集合；
• dynamic，动态库，是一种在程序运行时才被加载到内存中的库文件，多个程序共享一个动态库副本，而不是像静态库那样每个程序都包含一份完整的副本。

创建完成后，打开src/main.cj，点击编辑器右上角运行按钮直接运行，终端窗口可以看到打印内容。

后续文档中的代码验证均可以替换main.cj中的代码（package demo包路径保留）后执行，demo是项目名称，与创建项目时设置的保持一致。

至此，云主机环境配置完毕。

3 泛型

3.1 什么是泛型

在仓颉编程语言中，泛型是一种通过参数化类型来增强代码复用性和类型安全性的机制，class、interface、struct、enum均可声明类型形参。我们以一个泛型列表的声明进行学习：

//定义泛型列表
class List<T> {
    //elem的类型是Option<T>，表示可空值
var elem: Option<T> = None
//tail的类型Option<List<T>>，递归类型，通过Option实现链表
    var tail: Option<List<T>> = None
}
//函数参数类型为List<Int64>
func sumInt(a: List<Int64>) {  }

（* Option类型：Option 类型被定义为一个泛型 enum 类型，当需要表示某个类型可能有值，也可能没有值的时候，可选择使用 Option 类型）

• 核心概念：

1. 泛型

   允许在声明类型或函数时使用类型形参，这些参数在使用时由具体类型（类型实参）替换，从而创建特定类型的实例或函数。例如，List<T>中的T是类型形参，使用时指定List<Int64>，Int64即为类型实参。

2. 类型形参

   声明泛型时定义的占位符类型，如class List<T>中的T。它表示一个未知类型，需在使用时指定。

3. 类型实参

   在使用泛型时提供的具体类型，如List<Int64>中的Int64，用于替换类型形参。

4. 类型变元

   在泛型声明体中引用的类型形参。例如，List<T>内部成员elem: Option<T>中的T即为类型变元，指向声明时的类型形参。

5. 类型构造器

   需要类型实参来构造具体类型的泛型类型。例如，List本身是类型构造器，接受一个类型实参（如Int64）生成具体类型List<Int64>。

   通过泛型，仓颉语言实现了高度抽象和类型安全的代码设计，是构建通用库和复杂数据结构的基石。

3.2 泛型函数

• 泛型函数

允许在函数声明时定义类型形参，调用时根据实际参数类型自动推断或显式指定类型实参，从而实现同一函数逻辑适用于多种类型。

func identity<T>(x: T) -> T {
    return x
}

T是类型形参，在调用时被具体类型（如 Int64）替换。

• 语法规则

类型形参紧跟在函数名后，并用 <> 括起，如果有多个类型形参，则用“,”分离。可以在函数形参、返回类型、以及函数体中对类型形参进行引用。

• 分类

全局泛型函数：直接声明在文件作用域，类型参数 <T> 紧跟函数名。

局部泛型函数：嵌套在其他函数内，作用域受限。

泛型成员函数：类/结构体/枚举内部定义，可添加类型约束 (where)。

静态泛型函数：用 static 修饰，通过类型名直接调用。

下面这段代码中定义了以上四种类型的泛型函数：

// ================== 1. 全局泛型函数 ==================
// 定义在全局作用域，所有位置可调用
func f1<T1>(x: T1): Unit where T1 <: ToString{
    print("全局泛型函数: " + x.toString())

    // ================== 2. 局部泛型函数 ==================
    // 定义在f1函数内部的局部泛型函数
    func f2<T2>(a: T2): T2 { a }

    //f2函数仅支持f1作用域内调用
    var result = f2("cangjie")
    print("\n局部泛型函数: " + result)
}

//定义类
class Utils {
    // ================== 3. 泛型成员函数 ==================
    // 泛型成员函数：可被实例调用
    func f3<T3>(a: T3): T3 {
        print("\n泛型成员函数")
        return a
    }

    // ================== 4. 静态泛型函数 ==================
    // 静态方法，通过类名调用
    public static func f4<T4>(b: T4): T4 {
        print("\n静态泛型函数")
        return b
    }
}

// ================== 执行程序入口 ==================
main(): Unit {
    f1("hello")
    var utils = Utils()
    utils.f3(333)
    Utils.f4(true)
}

（* 注意：f1函数中使用了where做泛型约束，泛型约束详情可以到3.4.3泛型约束章节学习；f1函数也用到了<:操作符表示实现内置接口ToString，<:详情可以到3.4.1泛型类型的子类型关系章节学习）

运行以上程序，将输出：

需要注意在class 中声明的泛型成员函数不能被 open 修饰，如果被 open 修饰则会报错，例如：

class A {
    public open func foo<T>(a: T): Unit where T <: ToString { // Error, open generic function is not allowed
        println("${a}")
    }
}

（* open修饰符，用来标明一个类可以被继承，或者一个对象成员函数可以被子类重写）

3.3 支持的泛型类型

上文提到在仓颉中，class、interface、struct 与 enum 的声明都可以声明类型形参，也就是说它们都可以是泛型的。下面我们就来看一下他们在仓颉编程语言中是怎么定义的？又有哪些使用规范？

• 泛型类

泛型类通过类型参数（如 <T>）实现代码的通用性，允许在类定义时延迟类型的指定，直到使用时才确定具体类型。在定义类时类型形参紧跟在接口名后，并用 <> 括起，如果有多个类型形参，则用“,”分离，其语法为：

public class ClassName<T1, T2, ..., Tn> { /* class 定义体 */ }

• 泛型接口

泛型接口允许接口方法使用类型参数，实现更灵活的抽象设计。声明方式与泛型类一致，接口方法可直接使用类型参数，其语法为：

public interface InterfaceName<T1, T2, ..., Tn> { /* interface 定义体 */ }

• 泛型结构体

声明方式与泛型类类似，支持多个参数（如 <T1, T2>），其语法为：

public struct StructName<T1, T2, ..., Tn> {  /* struct 定义体 */ }

• 泛型枚举

声明方式与泛型类类似，支持多个参数（如 <T1, T2>），泛型 enum 声明的类型里被使用得最广泛的例子之一就是Option类型（Option 类型是用来表示在某一类型上的值可能是个空的值）。泛型枚举语法为：

public enum EnumName<T1, T2, ..., Tn> {  /* enum 定义体 */ }

我们拿泛型结构体举个例子，看一下在实际编程时是如何使用的。下面可以使用 struct 定义一个类似于二元元组的类型：

struct Pair<T, U> {
    //二元元组中的两个元素: x , y，类型形参是T , U
    let x: T
let y: U
//初始化元组函数
    public init(a: T, b: U) {
        x = a
        y = b
}
//获取二元元组第一个元素
    public func first(): T {
        return x
}
//获取二元元组第二个元素
    public func second(): U {
        return y
    }
}

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

运行以上程序，将输出：

3.4 使用注意事项

3.4.1 泛型类型的子类型关系

仓颉中，开发者定义的泛型类型（如 List<T>）在类型参数处默认是不型变的。这意味着，即使类型参数A是B的子类型，泛型类型 I<A> 和 I<B> 之间也没有子类型关系。

class D <: C {}  // D是C的子类
interface I<X> {}

I<D> 并不是 I<C> 的子类型，即使 D <: C。因为 I<T> 的类型参数T是不变的，只有类型参数完全相同时才成立子类型关系（如 I<D> <: I<D>）。

3.4.2 类型别名

当某个类型的名字比较复杂或者在特定场景中不够直观时，可以选择使用类型别名的方式为此类型设置一个别名，语法：

type 别名 = 原类型

（* 注意：只能在源文件顶层定义类型别名，并且原类型必须在别名定义处可见）

main() {
    type I64 = Int64 // 报错, 类型别名只能在原文件顶层定义
}

class LongNameClassA { }
type B = LongNameClassB // 报错：类型‘LongNameClassB’没有定义

类型别名也是可以声明类型形参的，当一个泛型类型的名称过长时，可以使用类型别名来为其声明一个更短的别名。如：

//泛型结构体
struct RecordData<T> {
    var a: T
    public init(x: T){
        a = x
    }
}

type RD<T> = RecordData<T>

main(): Int64 {
    // RD<Int32>别名来代指 RecordData<Int32> 类型
    var struct1: RD<Int32> = RecordData<Int32>(2)
    return 1
}

3.4.3 泛型约束

泛型约束的作用是在函数、class、enum、struct 声明时明确泛型形参所具备的操作与能力，限制泛型类型参数的范围，确保类型满足特定条件（如拥有某些方法或特性）。

约束大致分为接口约束与子类型约束。语法为在函数、类型的声明体之前使用 where 关键字来声明，对于声明的泛型形参 T1, T2，可以使用 where T1 <: Interface, T2 <: Type 这样的方式来声明泛型约束，同一个类型变元的多个约束可以使用 & 连接。例如：where T1 <: Interface1 & Interface2。

例如，仓颉中的 println 函数能接受类型为字符串的参数，如果需要把一个泛型类型的变量转为字符串后打印在命令行上，可以对这个泛型类型变元加以约束，这个约束是 core 中定义的 ToString 接口，显然它是一个接口约束：

package core // `ToString` 被定义在code包中

public interface ToString {
    func toString(): String
}

利用这个约束，定义一个名为 genericPrint 的函数：

// 泛型约束，T是ToString接口的子类型
func genericPrint<T>(a: T) where T <: ToString {
    println(a)
}

main() {
    genericPrint<Int64>(10)
    return 0
}

运行以上程序，将输出：

删除约束（如图注释掉约束代码），提示编译报错：

4 扩展

4.1 什么是扩展

扩展是一种为现有类型添加新功能而不修改原始类型定义的机制。它可以为当前package中可见的类型（不包括函数、元组和接口）添加额外功能。

• 适用场景

1. 当需要为类型添加功能但不能或不想破坏其封装性时；
2. 当无法修改原始类型源代码时（如系统库或第三方库中的类型）；
3. 当需要为类型临时添加特定功能时。

• 可添加的功能

1. 添加成员函数；
2. 添加操作符重载函数；
3. 添加成员属性（计算属性）；
4. 实现接口。

• 限制与约束

1. 不能添加存储属性：扩展不能增加实际的成员变量；
2. 必须提供实现：扩展的函数和属性必须有具体实现；
3. 修饰符限制：不能使用 open、override 或 redef 修饰；
4. 访问权限限制：不能访问被扩展类型中 private 修饰的成员；
5. 封装性不变：不能改变被扩展类型的原有封装性。

• 扩展分类

1. 直接扩展：不包含额外接口的扩展，仅添加新功能而不实现新接口；
2. 接口扩展：包含接口实现的扩展，可以为现有类型添加新功能并实现接口，增强类型的抽象灵活性。

使用建议：优先考虑直接扩展，保持简单性。当需要多态行为或接口抽象时使用接口扩展，注意扩展的可见性范围（与原始类型相同package），避免过度使用扩展导致代码分散。

4.2 直接扩展

直接扩展使用extend关键字声明，后跟被扩展的类型和扩展体。例如：

// 被扩展的类型 String
extend String {
    // 为 String 扩展了printSize函数
    public func printSize() {
        println("the size is ${this.size}")
    }
}
main() {
let a = "123"
// 对String的实例访问扩展函数printSize
    a.printSize() // the size is 3
}

当为String扩展了printSize函数之后，就能在当前package内对String的实例访问该函数，就像是String本身具备该函数。

运行以上程序，将输出：

4.3 接口扩展

接口扩展使用extend关键字声明，后跟类型和要实现的接口。例如：

// 定义接口和函数
interface PrintSizeable {
    func printSize(): Unit
}
// 被扩展的类型Array<T> 和 实现接口PrintSizeable
extend<T> Array<T> <: PrintSizeable {
    // 实现printSize函数
    public func printSize() {
        println("The size is ${this.size}")
    }
}
main() {
    // 将Array作为PrintSizeable的实现类型来使用
    let a: PrintSizeable = Array<Int64>()
    a.printSize() // 0
}

类型Array本身没有实现接口PrintSizeable，但可以通过扩展的方式为Array增加额外的成员函数printSize，并实现PrintSizeable。当使用扩展为Array实现PrintSizeable之后，就相当于在Array定义时实现接口PrintSizeable。

（* 注意：可以在同一个扩展内同时实现多个接口，多个接口之间使用&分开，接口的顺序没有先后关系）

运行以上程序，将输出：

4.4 访问规则

4.4.1 扩展的修饰符

扩展本身不能使用任何修饰符修饰，但扩展内的成员可以使用特定修饰符。扩展成员可使用的修饰符有：static、public、protected、internal、private、mut，扩展内的成员定义不支持使用 open、override、redef 修饰，注意：

• 使用 private 修饰的成员只能在本扩展内使用，外部不可见。
• 使用 internal 修饰的成员可以在当前包及子包（包括子包的子包）内使用，这是默认行为。
• 使用 protected 修饰的成员在本模块内可以被访问（受导出规则限制）。当被扩展类型是 class 时，该 class 的子类定义体内也能访问。
• 使用 static 修饰的成员，只能通过类型名访问，不能通过实例对象访问。
• 对 struct 类型的扩展可以定义 mut 函数。

public open class A {}
// 定义对类A的扩展
extend A {
    // 扩展成员支持的修饰符
    public func f1() {}
    protected func f2() {}
    private func f3() {}
static func f4() {}
// 扩展成员不支持的修饰符
public override func f5() {} // Error
public open func f6() {} // Error
redef static func f7() {} // Error
}
// 扩展不支持修饰符修饰
public extend A { } // Error

main() {
    A.f4()
    var a = A()
    a.f1()
    a.f2()
}

4.4.2 扩展的孤儿规则

为了防止类型被意外实现不合适的接口，存在"孤儿扩展"限制：既不与接口定义在同一个包中，也不与被扩展类型定义在同一个包中的接口扩展，不能为package A的类型实现package B的接口，除非扩展定义在A或B中。例如：

// package a
public class Foo {}

// package b
public interface Bar {}

// package c
import a.Foo
import b.Bar

extend Foo <: Bar {} // Error，孤儿扩展

4.4.3 扩展的访问和遮盖

• 访问

扩展实例成员可以使用this访问被扩展类型对象，同样也可以省略 this 访问成员，但扩展的实例成员不能使用 super。另外，扩展不能访问被扩展类型中 private 修饰的成员。例如：

class A {
var v = 0
private var v1 = 0
}

extend A {
    func f() {
        print(this.v) // Ok，使用this访问成员
        print(v) // Ok，省略this访问成员
        print(v1) // Error，不能访问被扩展类型中private修饰的成员
    }
}

（* 注意：在同一个包内，对同一类型可以扩展多次，并且在扩展中可以直接调用被扩展类型的其他扩展中非private修饰的函数）

• 遮盖

扩展不能遮盖被扩展类型的任何成员和其它扩展增加的任何成员。

class A {
    func f() {}
}
extend A {
    func f1() {}
}
extend A {
func f() {} // Error，不能遮盖被扩展类型的成员
func f1() {} // Error，不能遮盖扩展增加的成员
}

4.4.4 扩展的导入导出

• 直接扩展导出条件

扩展与被扩展类型在同一包中，被扩展类型和成员都使用public或protected修饰，除此以外的直接扩展均不能被导出，只能在当前包使用。

如以下代码所示，Foo是使用public修饰的类型，并且f与Foo 在同一个包内，因此f会跟随Foo一起被导出。而g和Foo不在同一个包，因此g不会被导出。

// package a
public class Foo {}
extend Foo {
    public func f() {}
}
// package b
import a.*
extend Foo {
    public func g() {}
}
// package c
import a.*
import b.*
main() {
    let a = Foo()
    a.f() // OK
    a.g() // Error
}

• 接口扩展导出条件

情况1：扩展与被扩展类型同包，接口来自导入时，需被扩展类型为public。

情况2：扩展与接口同包时，需接口为public。

如下代码所示，Foo 和 I 都使用了 public 修饰，因此对 Foo 的扩展就可以被导出。

// package a
public class Foo {}
public interface I {
    func g(): Unit
}
extend Foo <: I {
    public func g(): Unit {}
}

// package b
import a.*
main() {
    let a: I = Foo()
    a.g()
}

• 导入规则

直接扩展：只需导入被扩展类型。

接口扩展：需同时导入被扩展类型和接口。

如下面的代码所示，在package b中，只需要导入Foo就可以使用Foo对应的扩展中的函数f。

而对于接口扩展，需要同时导入被扩展的类型和扩展的接口才能使用，因此在package c中，需要同时导入Foo和I才能使用对应扩展中的函数g。

// package a
public class Foo {}
extend Foo {
    public func f() {}
}

// package b
import a.Foo
public interface I {
    func g(): Unit
}
extend Foo <: I {
    public func g() {
        this.f() // OK
    }
}

// package c
import a.Foo
import b.I
func test() {
    let a = Foo()
    a.f() // OK
    a.g() // OK
}

仓颉语言的泛型和扩展的介绍告一段落。

如果想了解更多仓颉编程语言知识可以访问： https://cangjie-lang.cn/