仓颉编程语言标准库 API

仓颉编程语言标准库 std 模块，每个模块下包含若干包，提供与该模块相关的具体而丰富的功能。

标准库为开发者提供了最通用的 API，包括输入输出功能、基础数据结构和算法、日期和时间表示等。

标准库遵守仓颉语言编程规范，在功能、性能、安全等方面符合官方标准。

使用介绍

在仓颉编程语言中，包是编译的最小单元，每个包可以单独输出 AST 文件、静态库文件、动态库文件等产物。包可以定义子包，从而构成树形结构。没有父包的包称为 root 包，root 包及其子包（包括子包的子包）构成的整棵树称为模块（module）。模块的名称与 root 包相同，是第三方开发者发布的最小单元。

包的导入规则如下：

• 可以导入某个包中的一个顶层声明或定义，语法如下：

  import fullPackageName.itemName
  

  其中 fullPackageName 为完整路径包名，itemName 为声明的名字，例如：

  import std.collection.ArrayList
  

• 如果要导入的多个 itemName 同属于一个 fullPackageName，可以使用：

  import fullPackageName.{itemName[, itemName]*}
  

  例如：

  import std.collection.{ArrayList, HashMap}
  

• 还可以将 fullPackageName 包中所有 public 修饰的顶层声明或定义全部导入，语法如下：

  import fullPackageName.*
  

  例如：

  import std.collection.*
  

模块列表

当前仓颉标准库提供了如下模块：

std 模块

std 功能介绍

std 模块意指标准库，标准库是指在编程语言中预先定义的一组函数、类、结构体等，旨在提供常用的功能和工具，以便开发者能够更快速、更高效地编写程序。

仓颉标准库提供的能力包括（不限于）：

• 输入输出：控制台输入输出、文件输入输出等。
• 数据结构：数组、链表、哈希表等。
• 算法：排序、求和、求幂、求对数等。
• 日期和时间：获取时间、格式化时间、设置定时任务等。
• 并发编程：锁、原子操作等。

仓颉标准库有其三项特点和追求：

• 使用方便：标准库随编译器、工具链一起发布，不需要用户另外下载，开箱即用。
• 功能通用：标准库提供了开发者最常使用的一些库能力，旨在为开发者解决大部分基础问题。
• 质量标杆：标准库追求在性能、代码风格等方面为其他仓颉库树立范例和标杆。

std 模块的包列表

std 模块提供了如下包：

std.core 包

功能介绍

core 包是标准库的核心包，提供了适用仓颉语言编程最基本的一些 API 能力。

提供了内置类型（有符号整型、无符号整型、浮点型等）、常用函数（print、println、eprint 等）、常用接口（ToString、Hashable、Equatable、Collection 等）、常用类和结构体（Array、String、Range 等）、常用异常类（Error、Exception 以及它们的一些细分子类）。

说明：

core 包不需要显式导入，默认导入。

API 列表

函数

类型别名

内置类型

接口

类

枚举

结构体

异常类

函数

func acquireArrayRawData<T>(Array<T>) where T <: CType

public unsafe func acquireArrayRawData<T>(arr: Array<T>): CPointerHandle<T> where T <: CType

功能：获取 Array<T> 中数据的原始指针实例，指针实例指向数组首元素的地址，T 需要满足 CType 约束。

注意：

指针使用完后需要及时用 releaseArrayRawData 函数释放该指针。 指针的获取和释放之间仅可包含简单的 foreign C 函数调用等逻辑，不构造例如 CString 等的仓颉对象，否则可能造成不可预期现象。

参数：

• arr: Array<T> - 待获取原始指针的数组。

返回值：

• CPointerHandle<T> - 数组的原始指针实例。

示例：

main() {
    var arr: Array<Int64> = [1, 2, 3, 4]  
    var cptrHandle: CPointerHandle<Int64> = unsafe { acquireArrayRawData(arr) }
    var cptr: CPointer<Int64> = cptrHandle.pointer

    let num: Int64 = unsafe { cptr.read() } 
    println("The first element of the array is ${num} ")
    
    unsafe { releaseArrayRawData<Int64>(cptrHandle) }
}

输出结果为：

The first element of the array is 1

func alignOf<T>() where T <: CType

public func alignOf<T>(): UIntNative where T <: CType

功能：获取类型 T 的内存对齐值。

返回值：

• UIntNative - 类型 T 满足内存对齐要求的字节数。

示例：

@C
struct Data {
    var a: Int64 = 0
    var b: Float32 = 0.0
}

main() {
    let alignSizeInt8: UIntNative = alignOf<Int8>()
    println("The memory alignment requirement for Int64 type is ${alignSizeInt8} byte")

    let alignSizeInt32: UIntNative = alignOf<Int32>()
    println("The memory alignment requirement for Int64 type is ${alignSizeInt32} bytes")

    let alignSizeInt64: UIntNative = alignOf<Int64>()
    println("The memory alignment requirement for Int64 type is ${alignSizeInt64} bytes")

    let alignSizeData: UIntNative = alignOf<Data>()
    println("The memory alignment requirement for Int64 type is ${alignSizeData} bytes")
}

输出结果为：

The memory alignment requirement for Int64 type is 1 byte
The memory alignment requirement for Int64 type is 4 bytes
The memory alignment requirement for Int64 type is 8 bytes
The memory alignment requirement for Int64 type is 8 bytes

func eprint(String, Bool)

public func eprint(str: String, flush!: Bool = true): Unit

功能：将指定字符串打印到标准错误文本流。

如抛出异常时，消息将打印到标准错误文本流（stderr），而不是标准输出（stdout）。

参数：

• str: String - 待输出的字符串。
• flush!: Bool - 是否将缓存数据区的内容立即刷新写入与标准错误流相关的文件和设备中，true表示立即刷新，false表示暂不刷新 ，默认 false。

示例：

main() {
    try {
        throw NegativeArraySizeException("I am an Exception!")
    } catch (e: NegativeArraySizeException) {
        eprint("NegativeArraySizeException is caught!", flush: true)
    }
}

输出结果为：

NegativeArraySizeException is caught!

func eprintln(String)

public func eprintln(str: String): Unit

功能：将指定字符串打印到标准错误文本流，末尾添加换行。

如抛出异常时，消息将打印到标准错误文本流（stderr），而不是标准输出（stdout）。

参数：

• str: String - 待输出的字符串。

示例：

main() {
    try {
        throw NegativeArraySizeException("I am an Exception!")
    } catch (e: NegativeArraySizeException) {
        eprintln("NegativeArraySizeException is caught!")
    }
}

输出结果为：

NegativeArraySizeException is caught!

func eprint<T>(T, Bool) where T <: ToString

public func eprint<T>(arg: T, flush!: Bool = false): Unit where T <: ToString

功能：将指定 T 类型实例的字符串表示打印到标准错误文本流。

如抛出异常时，消息将打印到标准错误文本流（stderr），而不是标准输出（stdout）。

参数：

• arg: T - 待打印的 T 类型实例，该函数将打印其 toString 的返回值。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

class Rectangle <: ToString{
    var width: Int64
    var height: Int64

    public init(width: Int64, height: Int64) {
        this.width = width
        this.height = height
    }

    public func area() {
        width * height
    }
    public func toString(): String{
        return "width: ${this.width}, height: ${this.height}"
    }
}

main() {
    try {
        throw NegativeArraySizeException("I am an Exception!")
    } catch (e: NegativeArraySizeException) {
        eprint<Rectangle>(Rectangle(10,20), flush: true)
    }
}

输出结果为：

width: 10, height: 20

func eprintln<T>(T) where T <: ToString

public func eprintln<T>(arg: T): Unit where T <: ToString

功能：将指定 T 类型实例的字符串表示打印到标准错误文本流，末尾添加换行。

如抛出异常时，消息将打印到标准错误文本流（stderr），而不是标准输出（stdout）。

参数：

• arg: T - 待打印的 T 类型实例，该函数将打印其 toString 的返回值。

示例：

class Rectangle <: ToString{
    var width: Int64
    var height: Int64

    public init(width: Int64, height: Int64) {
        this.width = width
        this.height = height
    }

    public func area() {
        width * height
    }
    public func toString(): String{
        return "width: ${this.width}, height: ${this.height}"
    }
}

main() {
    try {
        throw NegativeArraySizeException("I am an Exception!")
    } catch (e: NegativeArraySizeException) {
        eprintln<Rectangle>(Rectangle(10,20))
    }
}

输出结果为：

width: 10, height: 20

func ifNone<T>(Option<T>, () -> Unit)

public func ifNone<T>(o: Option<T>, action: () -> Unit): Unit

功能：如果输入是 Option.None 类型数据，则执行 action 函数。

参数：

• o: Option<T> - 待判断是否为 Option.None 的 Option<T> 类型实例。
• action: () ->Unit - 待执行函数。

示例：

main() {
    let num: Option<Int64> = None
    ifNone<Int64>(num,{=> println("num is None")})
}

输出结果为：

num is None

func ifSome<T>(Option<T>, (T) -> Unit)

public func ifSome<T>(o: Option<T>, action: (T) -> Unit): Unit

功能：如果输入是 Option.Some 类型数据，则执行 action 函数。

参数：

• o: Option<T> - 待判断是否为 Option.Some 的 Option<T> 类型实例，同时其封装的 T 类型实例将作为 action 函数的输入。
• action: (T) ->Unit - 待执行函数。

示例：

main() {
    let num: Option<Int64> = Some(200)
    ifSome<Int64>(num,{numValue: Int64 => println("num is ${numValue}")})
}

输出结果为：

num is 200

func max<T>(T, T, Array<T>) where T <: Comparable<T>

public func max<T>(a: T, b: T, others: Array<T>): T where T <: Comparable<T>

功能：根据 T 类型的 Comparable 接口实现，返回一组数据中的最大值，由于此函数的第三个参数是一个变长参数，支持获取二个以上的数据的比较。

注意：

浮点数类型的比较也将按照Comparable的结果进行比较，如果浮点书中有非数NaN，结果将不正确，此时建议使用 Float16、Float32、Float64 的 static func max方法。

参数：

• a: T - 第一个待比较的数。
• b: T - 第二个待比较的数。
• others: Array<T> - 其它待比较的数。

返回值：

• T - 返回参数中的最大值。

示例：

class Rectangle <: Comparable<Rectangle> & ToString{
    var width: Int64
    var height: Int64

    public init(width: Int64, height: Int64) {
        this.width = width
        this.height = height
    }

    public prop area: Int64 {
        get() {
            return this.width * this.height
        }
    }
    public func compare(t: Rectangle): Ordering {
        println(this)
        if(t.area > this.area){
            return Ordering.LT
        }else if(t.area == this.area){
            return Ordering.EQ
        }else{
            Ordering.GT
        }
    }
    public func toString(): String{
        return "width: ${this.width}, hright: ${this.height}, area: ${this.area}"
    }
}
main() {
    var r1: Rectangle = Rectangle(10,20)
    var r2: Rectangle = Rectangle(20,30)
    println("The larger one is ${max(r1,r2)}")
}

输出结果为：

The larger one is width: 20, hright: 30, area: 600

func min<T>(T, T, Array<T>) where T <: Comparable<T>

public func min<T>(a: T, b: T, others: Array<T>): T where T <: Comparable<T>

功能：根据 T 类型的 Comparable 接口实现，返回一组数据中的最小值，由于此函数的第三个参数是一个变长参数，支持获取二个以上的数据的比较。

注意：

浮点数类型的比较也将按照Comparable的结果进行比较，如果浮点书中有非数NaN，结果将不正确，此时建议使用 Float16、Float32、Float64 的 static func min方法。

参数：

• a: T - 第一个待比较的数。
• b: T - 第二个待比较的数。
• others: Array<T> - 其它待比较的数。

返回值：

• T - 返回参数中的最小值。

示例：

class Rectangle <: Comparable<Rectangle> & ToString {
    var width: Int64
    var height: Int64

    public init(width: Int64, height: Int64) {
        this.width = width
        this.height = height
    }
    public prop area: Int64 {
        get() {
            return this.width * this.height
        }
    }
    public func compare(t: Rectangle): Ordering {
        if(t.area > this.area){
            return Ordering.LT
        }else if(t.area == this.area){
            return Ordering.EQ
        }else{
            Ordering.GT
        }
    }
    public func toString(): String {
        return "width: ${this.width}, hright: ${this.height}, area: ${this.area}"
    }
}

main() {
    var r1: Rectangle = Rectangle(10, 20)
    var r2: Rectangle = Rectangle(20, 30)
    println("The smaller one is ${min(r1, r2)}")
}

输出结果为：

The smaller one is width: 10, hright: 20, area: 200

func print(Bool, Bool)

public func print(b: Bool, flush!: Bool = false): Unit

功能：向控制台输出 Bool 类型数据的字符串表达。

注意：

下列 print、 println、 eprint、 eprintln 函数默认为 UTF-8 编码。

参数：

• b: Bool - 待输出的 Bool 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var flag: Bool = false
    print(flag)
    flag = true
    println()
    print(flag)
}

输出结果为：

false
true

func print(Float16, Bool)

public func print(f: Float16, flush!: Bool = false): Unit

功能：向控制台输出 Float16 类型数据的小数点后六位的字符串表达，即超出六位的小数位不会输出，不足六位的小数位会补零。

参数：

• f: Float16 - 待输出的 Float16 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: Float16 = 0.76
    var num2: Float16 = 0.68
    print(num1)
    println()
    print(num2)
}

输出结果为：

0.759766
0.680176

注意：

仓颉采用IEEE 754格式表示浮点数，保存数值可能会有误差。

func print(Float32, Bool)

public func print(f: Float32, flush!: Bool = false): Unit

功能：向控制台输出 Float32 类型数据的的小数点后六位的字符串表达，即超出六位的小数位不会输出，不足六位的小数位会补零。

参数：

• f: Float32 - 待输出的 Float32 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: Float16 = 0.76
    var num2: Float16 = 0.68
    print(num1)
    println()
    print(num2)
}

输出结果为：

0.764530
0.683456

func print(Float64, Bool)

public func print(f: Float64, flush!: Bool = false): Unit

功能：向控制台输出 Float64 类型数据的的小数点后六位的字符串表达，即超出六位的小数位不会输出，不足六位的小数位会补零。

参数：

• f: Float64 - 待输出的 Float64 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: Float64 = 0.76453
    var num2: Float64 = 0.683456
    print(num1)
    println()
    print(num2)
}

输出结果为：

0.764530
0.683456

func print(Int16, Bool)

public func print(i: Int16, flush!: Bool = false): Unit

功能：向控制台输出 Int16 类型数据的字符串表达。

参数：

• i: Int16 - 待输出的 Int16 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: Int16 = 10
    var num2: Int16 = 2222
    print(num1)
    println()
    print(num2)
}

输出结果为：

10
2222

func print(Int32, Bool)

public func print(i: Int32, flush!: Bool = false): Unit

功能：向控制台输出 Int32 类型数据的字符串表达。

参数：

• i: Int32 - 待输出的 Int32 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: Int32 = 1024
    var num2: Int32 = 2048
    print(num1)
    println()
    print(num2)
}

输出结果为：

1024
2048

func print(Int64, Bool)

public func print(i: Int64, flush!: Bool = false): Unit

功能：向控制台输出 Int64 类型数据的字符串表达。

参数：

• i: Int64 - 待输出的 Int64 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: Int64 = 1024
    var num2: Int64 = 2048
    print(num1)
    println()
    print(num2)
}

输出结果为：

1024
2048

func print(Int8, Bool)

public func print(i: Int8, flush!: Bool = false): Unit

功能：向控制台输出 Int8 类型数据的字符串表达。

参数：

• i: Int8 - 待输出的 Int8 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: Int8 = 8
    var num2: Int8 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

8
32

func print(Rune, Bool)

public func print(c: Rune, flush!: Bool = false): Unit

功能：向控制台输出 Rune 类型数据的字符串表达。

参数：

• c: Rune - 待输出的 Rune 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var char: Rune = r'a'
    print(char)
}

输出结果为：

a

func print(String, Bool)

public func print(str: String, flush!: Bool = false): Unit

功能：向控制台输出指定字符串。

参数：

• str: String - 待输出的字符串。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var str: String = "I like Cangjie"
    print(str)
}

输出结果为：

I like Cangjie

func print(UInt16, Bool)

public func print(i: UInt16, flush!: Bool = false): Unit

功能：向控制台输出 UInt16 类型数据的字符串表达。

参数：

• i: UInt16 - 待输出的 UInt16 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: UInt16 = 8
    var num2: UInt16 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

8
32

func print(UInt32, Bool)

public func print(i: UInt32, flush!: Bool = false): Unit

功能：向控制台输出 UInt32 类型数据的字符串表达。

参数：

• i: UInt32 - 待输出的 UInt32 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: UInt16 = 8
    var num2: UInt16 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

8
32

func print(UInt64, Bool)

public func print(i: UInt64, flush!: Bool = false): Unit

功能：向控制台输出 UInt64 类型数据的字符串表达。

参数：

• i: UInt64 - 待输出的 UInt64 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: UInt64 = 8
    var num2: UInt64 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

a

func print(UInt8, Bool)

public func print(i: UInt8, flush!: Bool = false): Unit

功能：向控制台输出 UInt8 类型数据的字符串表达。

参数：

• i: UInt8 - 待输出的 UInt8 类型数据。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

main() {
    var num1: UInt8 = 8
    var num2: UInt8 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

8
32

func print<T>(T, Bool) where T <: ToString

public func print<T>(arg: T, flush!: Bool = false): Unit where T <: ToString

功能：向控制台输出 T 类型实例的字符串表示。

参数：

• arg: T - 待输出的数据，支持实现了 ToString 接口的类型。
• flush!: Bool - 是否清空缓存，true 清空，false 不清空，默认 false。

示例：

class Rectangle <: ToString {
    var width: Int64
    var height: Int64

    public init(width: Int64, height: Int64) {
        this.width = width
        this.height = height
    }

    public func area() {
        width * height
    }
    public func toString(): String {
        return "width: ${this.width}, hright: ${this.height}"
    }
}

main() {
    print<Rectangle>(Rectangle(10, 20))
}

输出结果为：

width: 10, hright: 20

func println()

public func println(): Unit

功能：向标准输出（stdout）输出换行符。

示例：

main() {
    var num1: UInt8 = 8
    var num2: UInt8 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

8
32

func println(Bool)

public func println(b: Bool): Unit

功能：向控制台输出 Bool 类型数据的字符串表达，末尾添加换行。

参数：

• b: Bool - 待输出的 Bool 类型数据。

示例：

main() {
    var flag1: Bool = true
    var flag2: Bool = false
    println(flag1)
    println(flag2)
}

输出结果为：

true
false

func println(Float16)

public func println(f: Float16): Unit

功能：向控制台输出 Float16 类型数据的字符串表达，末尾添加换行。

参数：

• f: Float16 - 待输出的 Float16 类型数据。

示例：

main() {
    var num1: Float16 = 3.1415
    var num2: Float16 = 3.141592
    println(num1)
    println(num2)
}

输出结果为：

3.140625
3.140625

func println(Float32)

public func println(f: Float32): Unit

功能：向控制台输出 Float32 类型数据的字符串表达，末尾添加换行。

参数：

• f: Float32 - 待输出的 Float32 类型数据。

示例：

main() {
    var num1: Float32 = 3.1415
    var num2: Float32 = 3.141592
    println(num1)
    println(num2)
}

输出结果为：

3.141500
3.141592

func println(Float64)

public func println(f: Float64): Unit

功能：向控制台输出 Float64 类型数据的字符串表达，末尾添加换行。

参数：

• f: Float64 - 待输出的 Float64 类型数据。

示例：

main() {
    var num1: Float64 = 3.1415
    var num2: Float64 = 3.141592
    println(num1)
    println(num2)
}

输出结果为：

3.141500
3.141592

func println(Int16)

public func println(i: Int16): Unit

功能：向控制台输出 Int16 类型数据的字符串表达，末尾添加换行。

参数：

• i: Int16 - 待输出的 Int16 类型数据。

示例：

main() {
    var num1: Int16 = 8
    var num2: Int16 = 32
    println(num1)
    println(num2)
}

输出结果为：

8
32

func println(Int32)

public func println(i: Int32): Unit

功能：向控制台输出 Int32 类型数据的字符串表达，末尾添加换行。

参数：

• i: Int32 - 待输出的 Int32 类型数据。

示例：

main() {
    var num1: Int32 = 8
    var num2: Int32 = 32
    println(num1)
    println(num2)
}

输出结果为：

8
32

func println(Int64)

public func println(i: Int64): Unit

功能：向控制台输出 Int64 类型数据的字符串表达，末尾添加换行。

参数：

• i: Int64 - 待输出的 Int64 类型数据。

示例：

main() {
    var num1: Int64 = 8
    var num2: Int64 = 32
    println(num1)
    println(num2)
}

输出结果为：

8
32

func println(Int8)

public func println(i: Int8): Unit

功能：向控制台输出 Int8 类型数据的字符串表达，末尾添加换行。

参数：

• i: Int8 - 待输出的 Int8 类型数据。

示例：

main() {
    var num1: Int8 = 8
    var num2: Int8 = 32
    println(num1)
    println(num2)
}

输出结果为：

8
32

func println(Rune)

public func println(c: Rune): Unit

功能：向控制台输出 Rune 类型数据的字符串表达，末尾添加换行。

参数：

• c: Rune - 待输出的 Rune 类型数据。

示例：

main() {
    var char1: Rune = r'a'
    var char2: Rune = r'b'
    println(char1)
    println(char2)
}

输出结果为：

a
b

func println(String)

public func println(str: String): Unit

功能：向控制台输出指定字符串，末尾添加换行。

参数：

• str: String - 待输出的字符串。

示例：

main() {
    var str1: String = "I like Cangjie"
    var str2: String = "I like programming"
    println(str1)
    println(str2)
}

输出结果为：

I like Cangjie
I like programming

func println(UInt16)

public func println(i: UInt16): Unit

功能：向控制台输出 UInt16 类型数据的字符串表达，末尾添加换行。

参数：

• i: UInt16 - 待输出的 UInt16 类型数据。

示例：

main() {
    var num1: UInt16 = 8
    var num2: UInt16 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

8
32

func println(UInt32)

public func println(i: UInt32): Unit

功能：向控制台输出 UInt32 类型数据的字符串表达，末尾添加换行。

参数：

• i: UInt32 - 待输出的 UInt32 类型数据。

示例：

main() {
    var num1: UInt32 = 8
    var num2: UInt32 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

8
32

func println(UInt64)

public func println(i: UInt64): Unit

功能：向控制台输出 UInt64 类型数据的字符串表达，末尾添加换行。

参数：

• i: UInt64 - 待输出的 UInt64 类型数据。

示例：

main() {
    var num1: UInt64 = 8
    var num2: UInt64 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

8
32

func println(UInt8)

public func println(i: UInt8): Unit

功能：向控制台输出 UInt8 类型数据的字符串表达，末尾添加换行。

参数：

• i: UInt8 - 待输出的 UInt8 类型数据。

示例：

main() {
    var num1: UInt8 = 8
    var num2: UInt8 = 32
    print(num1)
    println()
    print(num2)
}

输出结果为：

8
32

func println<T>(T) where T <: ToString

public func println<T>(arg: T): Unit where T <: ToString

功能：向控制台输出 T 类型实例的字符串表示，末尾添加换行。

参数：

• arg: T - 待输出的数据，支持实现了 ToString 接口的类型。

示例：

class Rectangle <: ToString {
    var width: Int64
    var height: Int64

    public init(width: Int64, height: Int64) {
        this.width = width
        this.height = height
    }

    public func area() {
        width * height
    }
    public func toString(): String {
        return "width: ${this.width}, hright: ${this.height}"
    }
}

main() {
    println<Rectangle>(Rectangle(10, 20))
    println<Rectangle>(Rectangle(5, 10))
}

输出结果为：

width: 10, hright: 20
width: 5, hright: 10

func readln()

public func readln(): String

功能：接受控制台输入，直到遇到换行或EOF结束。

返回值：

• String - 接受到的字符串。

示例：

main() {
    var str: String = readln() //Console input 12345 234 and enter 
    println(str)
}

输出结果为：

12345 234

func refEq(Object, Object)

public func refEq(a: Object, b: Object): Bool

功能：判断两个 Object 实例的内存地址是否相同。

参数：

• a: Object - 一个 Object 实例。
• b: Object - 另一个 Object 实例。

返回值：

• Bool - 如果两个 Object 实例的内存地址相同，返回 true，否则返回 false。

示例：

class Rectangle {
    var width: Int64
    var height: Int64

    public init(width: Int64, height: Int64) {
        this.width = width
        this.height = height
    }
}

main() {
    var r1: Rectangle = Rectangle(10, 20)
    var r2: Rectangle = r1
    var r3: Rectangle = Rectangle(5, 6)
    println(refEq(r1, r2))
    println(refEq(r1, r3))
}

输出结果为：

true
false

func releaseArrayRawData<T>(CPointerHandle<T>) where T <: CType

public unsafe func releaseArrayRawData<T>(handle: CPointerHandle<T>): Unit where T <: CType

功能：释放原始指针实例，该实例通过 acquireArrayRawData 获取。

参数：

• handle: CPointerHandle<T> - 待释放的指针实例。

示例：

main() {
    var arr: Array<Int64> = [1, 2, 3, 4]
    var cptrHandle: CPointerHandle<Int64> = unsafe { acquireArrayRawData(arr) }

    var cptr: CPointer<Int64> = cptrHandle.pointer
    let num: Int64 = unsafe { cptr.read() }
    println("The first element of the array is ${num} ")

    unsafe { releaseArrayRawData<Int64>(cptrHandle) }
}

输出结果为：

The first element of the array is 1

func sizeOf<T>() where T <: CType

public func sizeOf<T>(): UIntNative where T <: CType

功能：获取类型 T 所占用的内存空间大小。

返回值：

• UIntNative - 类型 T 所占用内存空间的字节数。

示例：

@C
struct Data {
    var a: Int64 = 0
    var b: Float32 = 0.0
}

main() {
    let sizeInt8: UIntNative = sizeOf<Int8>()
    println("The size of Int8 is ${sizeInt8} byte")

    let sizeInt32: UIntNative = sizeOf<Int32>()
    println("The size of Int32 is ${sizeInt32} bytes")

    let sizeInt64: UIntNative = sizeOf<Int64>()
    println("The size of Int64 is ${sizeInt64} bytes")

    let sizeData: UIntNative = sizeOf<Data>()
    println("The size of Rectangle is ${sizeData} bytes")
}

输出结果为：

The size of Int8 is 1 byte
The size of Int32 is 4 bytes
The size of Int64 is 8 bytes
The size of Rectangle is 16 bytes

func sleep(Duration)

public func sleep(dur: Duration): Unit

功能：休眠当前线程。

若 dur 小于等于 Duration.Zero，当前线程会让出运行权。

参数：

• dur: Duration - 线程休眠的时长。

示例：

import std.sync.*
import std.time.*

main(): Int64 {
    spawn {
        =>
        println("New thread starts")
        println("New thread ends")
    }

    println("Main thread")
    println("The main thread starts to sleep.")

    /* dur == 1 秒 */
    sleep(1000 * Duration.millisecond)
    println("The main thread ends sleep.")

    return 0
}

在启动主线程后，执行到sleep函数的时候，主线程会让出系统执行权，并睡眠 1 秒后重新唤醒竞争系统执行权，继续执行剩余逻辑。在主线程睡眠期间，自定义线程拿到执行权，开始执行。输出结果为：

Main thread
The main thread starts to sleep.
New thread starts
New thread ends
The main thread ends sleep.

func zeroValue<T>()

public unsafe func zeroValue<T>(): T

功能：获取一个已全零初始化的 T 类型实例。

注意：

这个实例一定要赋值为正常初始化的值再使用，否则将引发程序崩溃。

返回值：

• T - 一个已全零初始化的 T 类型实例。

类型别名

type Byte

public type Byte = UInt8

功能：Byte 类型是内置类型 UInt8 的别名。

type Int

public type Int = Int64

功能：Int 类型是内置类型 Int64 的别名。

type UInt

public type UInt = UInt64

功能：UInt 类型是内置类型 UInt64 的别名。

内置类型

Bool

功能：表示布尔类型，有 true 和 false 两种取值。

extend Bool <: Equatable<Bool>

extend Bool <: Equatable<Bool>

功能：为 Bool 类型扩展 Equatable<Bool> 接口，支持判等操作。

父类型：

• Equatable<Bool>

extend Bool <: Hashable

extend Bool <: Hashable

功能：为 Bool 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

示例：

main() {
    var flag: Bool = false
    println(flag.hashCode())
    flag = true
    println(flag.hashCode())
}

输出结果为：

0
1

extend Bool <: ToString

extend Bool <: ToString

功能：为 Bool 类型其扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Bool 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

示例：

main() {
    var flag: Bool = false
    let str1: String = flag.toString()
    println(str1)
    flag = true
    let str2: String = flag.toString()
    println(str2)
}

输出结果为：

false
true

CPointer<T>

功能：表示 T 类型实例的指针，在与 C 语言互操作的场景下使用，对应 C 语言的 T*。

其中 T 必须满足 CType 约束。

CPointer 类型必须满足：

• 大小和对齐与平台相关。
• 对它做加减法算术运算、读写内存，是需要在 unsafe 上下文操作的。
• CPointer<T1> 可以在 unsafe 上下文中使用类型强制转换，变成 CPointer<T2> 类型。

extend<T> CPointer<T>

extend<T> CPointer<T>

功能：为 CPointer<T> 扩展一些必要的指针使用相关接口，包含判空、读写数据等接口。

其中泛型 T 为指针类型，其满足 CType 约束。对 CPointer 做运算需要在 unsafe 上下文中进行。

func asResource()

public func asResource(): CPointerResource<T>

功能：获取该指针 CPointerResource 实例，该实例可以在 try-with-resource 语法上下文中实现内容自动释放。

返回值：

• CPointerResource<T> - 当前指针对应的 CPointerResource 实例。

示例：

foreign func malloc(size: UIntNative): CPointer<Unit>

main() {
    let sizeofInt64: UIntNative = 8
    var p1 = unsafe { malloc(sizeofInt64) }
    var ptr = unsafe { CPointer<Int64>(p1) }
    unsafe { ptr.write(10) }
    var ptrResource: CPointerResource<Int64> = ptr.asResource()
    try (r = ptrResource) {
        var p = r.value
        let num: Int64 = unsafe { p.read() }
        println(num)
    }
    println(ptrResource.isClosed())
}

输出结果为：

10
true

func isNotNull()

public func isNotNull(): Bool

功能：判断指针是否不为空。

返回值：

• Bool - 如果不为空返回 true，否则返回 false。

示例：

foreign func malloc(size: UIntNative): CPointer<Unit>
foreign func free(ptr: CPointer<Unit>): Unit

main() {
    let p1 = CPointer<Int64>()
    println(p1.isNotNull())
    let sizeofInt64: UIntNative = 8
    var p2 = unsafe { malloc(sizeofInt64) }  
    println(p2.isNotNull())
    unsafe { free(p2) } 
}

输出结果为：

false
true

func isNull()

public func isNull(): Bool

功能：判断指针是否为空。

返回值：

• Bool - 如果为空返回 true，否则返回 false。

示例：

foreign func malloc(size: UIntNative): CPointer<Unit>

foreign func free(ptr: CPointer<Unit>): Unit

main() {
    let sizeofInt64: UIntNative = 8
    var p1 = unsafe { malloc(sizeofInt64) }
    var ptr = unsafe { CPointer<Int64>(p1) }
    unsafe { ptr.write(10) }
    let num: Int64 = unsafe { ptr.read() }
    println(num)
    unsafe { free(p1) }
}

输出结果为：

10

func read()

public unsafe func read(): T

功能：读取第一个数据，该接口需要用户保证指针的合法性，否则发生未定义行为。

返回值：

• T - 该对象类型的第一个数据。

示例：

foreign func malloc(size: UIntNative): CPointer<Unit>
foreign func free(ptr: CPointer<Unit>): Unit

main() {
    let p1 = CPointer<Int64>()
    println(p1.isNull())
    let sizeofInt64: UIntNative = 8
    var p2 = unsafe { malloc(sizeofInt64) }  
    println(p2.isNull())
    unsafe { free(p2) } 
}

输出结果为：

true
false

func read(Int64)

public unsafe func read(idx: Int64): T

功能：根据下标读取对应的数据，该接口需要用户保证指针的合法性，否则发生未定义行为。

参数：

• idx: Int64 - 要获取数据的下标。

返回值：

• T - 输入下标对应的数据。

示例：

main() {
    var arr: Array<Int64> = [1, 2, 3, 4]
    var cptrHandle: CPointerHandle<Int64> = unsafe { acquireArrayRawData(arr) }
    var cptr: CPointer<Int64> = cptrHandle.pointer

    let num: Int64 = unsafe { cptr.read(2) }
    println("The third element of the array is ${num} ")
    
    unsafe { releaseArrayRawData<Int64>(cptrHandle) }
}

输出结果为：

3

func toUIntNative()

public func toUIntNative(): UIntNative

功能：获取该指针的整型形式。

返回值：

• UIntNative - 该指针的整型形式。

示例：

foreign func malloc(size: UIntNative): CPointer<Unit>

foreign func free(ptr: CPointer<Unit>): Unit

main() {
    let sizeofInt64: UIntNative = 8
    var p = unsafe { malloc(sizeofInt64) }
    var p1 = unsafe { CPointer<Int64>(p) }
    unsafe { p1.write(8) }
    println(p1.toUIntNative())
    unsafe { free(p) }
}

输出结果为：

93954490863648

func write(Int64, T)

public unsafe func write(idx: Int64, value: T): Unit

功能：在指定下标位置写入一个数据，该接口需要用户保证指针的合法性，否则发生未定义行为。

参数：

• idx: Int64 - 指定的下标位置。
• value: T - 写入的数据。

示例：

main() {
    var arr: Array<Int64> = [1, 2, 3, 4]
    var cptrHandle: CPointerHandle<Int64> = unsafe { acquireArrayRawData(arr) }

    var cptr: CPointer<Int64> = cptrHandle.pointer

    unsafe { cptr.write(2, 6) }

    println("The third element of the array is ${arr[2]} ")
    //The first element of the array is 1
    unsafe { releaseArrayRawData<Int64>(cptrHandle) }
}

输出结果为：

The third element of the array is 6

func write(T)

public unsafe func write(value: T): Unit

功能：写入一个数据，该数据总是在第一个，该接口需要用户保证指针的合法性，否则发生未定义行为。

参数：

• value: T - 要写入的数据。

示例：

foreign func malloc(size: UIntNative): CPointer<Unit>
foreign func free(ptr: CPointer<Unit>): Unit

main() {
    let sizeofInt64: UIntNative = 8
    var p = unsafe { malloc(sizeofInt64) }    // malloc a Point3D in heap
    var p1 = unsafe { CPointer<Int64>(p) }
    unsafe { p1.write(8) }
    let value: Int64 = unsafe { p1.read() }
    println(value) 
    unsafe{ free(p) }
}

输出结果为：

8

operator func +(Int64)

public unsafe operator func +(offset: Int64): CPointer<T>

功能：CPointer 对象指针后移，同 C 语言的指针加法操作。

参数：

• offset: Int64 - 偏移量。

返回值：

• CPointer<T> - 返回偏移后的指针。

示例：

main() {
    var arr: Array<Int64> = [1, 2, 3, 4]
    var cptrHandle: CPointerHandle<Int64> = unsafe { acquireArrayRawData(arr) }
    var cptr: CPointer<Int64> = cptrHandle.pointer

    let num1: Int64 = unsafe { cptr.read() }
    println(num1)
    cptr = unsafe { cptr + 1 }
    let num2: Int64 = unsafe { cptr.read() }
    println(num2)
    unsafe { releaseArrayRawData<Int64>(cptrHandle) }
}

输出结果为：

1
2

operator func -(Int64)

public unsafe operator func -(offset: Int64): CPointer<T>

功能：CPointer 对象指针前移，同 C 语言的指针减法操作。

参数：

• offset: Int64 - 偏移量。

返回值：

• CPointer<T> - 返回偏移后的指针。

示例：

main() {
    var arr: Array<Int64> = [1, 2, 3, 4]
    var cptrHandle: CPointerHandle<Int64> = unsafe { acquireArrayRawData(arr) }
    var cptr: CPointer<Int64> = cptrHandle.pointer

    let num1: Int64 = unsafe { cptr.read() }
    println(num1)
    cptr = unsafe { cptr + 1 }
    let num2: Int64 = unsafe { cptr.read() }
    println(num2)
    cptr = unsafe { cptr - 1 }
    let num3: Int64 = unsafe { cptr.read() }
    println(num3)
    unsafe { releaseArrayRawData<Int64>(cptrHandle) }
}

输出结果为：

1
2
1

CString

功能：表示 C 风格字符串，在与 C 语言互操作的场景下使用。

可以通过 CString 的构造函数或 LibC 的 mallocCString 创建 C 风格字符串，如需在仓颉端释放，则调用 LibC 的 free 方法。

extend CString <: ToString

extend CString <: ToString

功能：为 CString 类型扩展一些字符串指针常用方法，包括判空、获取长度、判等、获取子串等。

父类型：

• ToString

func asResource()

public func asResource(): CStringResource

功能：获取当前 CString 实例对应的 CStringResource C 字符串资源类型实例。

CStringResource 实现了 Resource 接口，可以在 try-with-resource 语法上下文中实现资源自动释放。

返回值：

• CStringResource - 对应的 CStringResource C 字符串资源类型实例。

示例：

foreign func malloc(size: UIntNative): CPointer<Unit>

main() {
    var str: CString = unsafe { LibC.mallocCString("hello") }
    var ptrResource: CStringResource = str.asResource()
    try (r = ptrResource) {
        var p = r.value
        println(p.size())
    }
    println(ptrResource.isClosed())
}

输出结果为：

5
true

func compare(CString)

public func compare(str: CString): Int32

功能：按字典序比较两个字符串，同 C 语言中的 strcmp。

参数：

• str: CString - 比较的目标字符串。

返回值：

• Int32 - 两者相等返回 0，如果当前字符串比参数 str 小，返回 -1，否则返回 1。

异常：

• Exception - 如果被比较的两个 CString 中存在空指针，抛出异常。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    var str2: CString = unsafe { LibC.mallocCString("hello") }
    println(str1.compare(str2))

    var str3: CString = unsafe { LibC.mallocCString("hello") }
    var str4: CString = unsafe { LibC.mallocCString("hellow") }
    println(str3.compare(str4))

    var str5: CString = unsafe { LibC.mallocCString("hello") }
    var str6: CString = unsafe { LibC.mallocCString("allow") }
    println(str5.compare(str6))

    unsafe {
        LibC.free(str1)
        LibC.free(str2)
        LibC.free(str3)
        LibC.free(str4)
        LibC.free(str5)
        LibC.free(str6)
    }
}

输出结果为：

0
-1
1

func endsWith(CString)

public func endsWith(suffix: CString): Bool

功能：判断字符串是否包含指定后缀。

参数：

• suffix: CString - 匹配的目标后缀字符串。

返回值：

• Bool - 如果该字符串包含 suffix 后缀，返回 true，如果该字符串不包含 suffix 后缀，返回 false，特别地，如果原字符串或者 suffix 后缀字符串指针为空，均返回 false。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    var str2: CString = unsafe { LibC.mallocCString("lo") }
    var str3: CString = unsafe { LibC.mallocCString("ao") }

    println(ptr1.endsWith(ptr2))
    println(ptr1.endsWith(ptr3))

    unsafe {
        LibC.free(str1)
        LibC.free(str2)
        LibC.free(str3)
    }
}

输出结果为：

true
false

func equals(CString)

public func equals(rhs: CString): Bool

功能：判断两个字符串是否相等。

参数：

• rhs: CString - 比较的目标字符串。

返回值：

• Bool - 如果两个字符串相等，返回 true，否则返回 false。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    var str2: CString = unsafe { LibC.mallocCString("hello") }
    var str3: CString = unsafe { LibC.mallocCString("Hello") }
    println(str1.equals(str2))
    println(str1.equals(str3))

    unsafe {
        LibC.free(str1)
        LibC.free(str2)
        LibC.free(str3)
    }
}

输出结果为：

true
false

func equalsLower(CString)

public func equalsLower(rhs: CString): Bool

功能：判断两个字符串是否相等，忽略大小写。

参数：

• rhs: CString - 匹配的目标字符串。

返回值：

• Bool - 如果两个字符串忽略大小写相等，返回 true，否则返回 false。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    var str2: CString = unsafe { LibC.mallocCString("HELLO") }
    var str3: CString = unsafe { LibC.mallocCString("Hello") }
    println(str1.equalsLower(str2))
    println(str1.equalsLower(str3))

    unsafe {
        LibC.free(str1)
        LibC.free(str2)
        LibC.free(str3)
    }
}

输出结果为：

true
true

func getChars()

public func getChars(): CPointer<UInt8>

功能：获取该字符串的指针。

返回值：

• CPointer<UInt8> - 该字符串的指针。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    var ptr: CPointer<UInt8> = unsafe { str1.getChars() }
    var c: UInt8 = unsafe { ptr.read() }
    println(c) //h的ascii码为104
    unsafe{
        LibC.free(str1)
    }
}

输出结果为：

104

func isEmpty()

public func isEmpty(): Bool

功能：判断字符串是否为空字符串。

返回值：

• Bool - 如果为空字符串或字符串指针为空，返回 true，否则返回 false。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    println(str1.isEmpty())

    unsafe {
        LibC.free(str1)
    }
}

输出结果为：

false

func isNotEmpty()

public func isNotEmpty(): Bool

功能：判断字符串是否不为空字符串。

返回值：

• Bool - 如果不为空字符串，返回 true，如果字符串指针为空，返回 false。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    println(str1.isNotEmpty())

    unsafe {
        LibC.free(str1)
    }
}

输出结果为：

true

func isNull()

public func isNull(): Bool

功能：判断字符串指针是否为空。

返回值：

• Bool - 如果字符串指针为空，返回 true，否则返回 false。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    println(str1.isNull())

    unsafe {
        LibC.free(str1)
    }
}

输出结果为：

false

func size()

public func size(): Int64

功能：返回该字符串长度，同 C 语言中的 strlen。

返回值：

• Int64 - 字符串长度。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    println(str1.size())

    unsafe {
        LibC.free(str1)
    }
}

输出结果为：

5

func startsWith(CString)

public func startsWith(prefix: CString): Bool

功能：判断字符串是否包含指定前缀。

参数：

• prefix: CString - 匹配的目标前缀字符串。

返回值：

• Bool - 如果该字符串包含 prefix 前缀，返回 true，如果该字符串不包含 prefix 前缀，返回 false，特别地，如果原字符串或者 prefix 前缀字符串指针为空，均返回 false。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    var str2: CString = unsafe { LibC.mallocCString("he") }
    println(str1.startsWith(str2))

    unsafe {
        LibC.free(str1)
        LibC.free(str2)
    }
}

输出结果为：

true

func subCString(UIntNative)

public func subCString(beginIndex: UIntNative): CString

功能：截取指定位置开始至字符串结束的子串。

注意：

1. 该接口返回为字符串的副本，返回的子串使用完后需要手动 free。
2. 如果 beginIndex 与字符串长度相等，将返回空指针。

参数：

• beginIndex: UIntNative - 截取的起始位置，取值范围为 [0, this.size()]。

返回值：

• CString - 截取的子串。

异常：

• IndexOutOfBoundsException - 如果 beginIndex 大于字符串长度，抛出异常。
• IllegalMemoryException - 如果内存申请失败或内存拷贝失败时，抛出异常。

示例：

main() {
    let index: UIntNative = 2
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    var str2: CString = str1.subCString(index)
    println(str2)
    
    unsafe {
        LibC.free(str1)
        LibC.free(str2)
    }
}

输出结果为：

llo

func subCString(UIntNative, UIntNative)

public func subCString(beginIndex: UIntNative, subLen: UIntNative): CString

功能：截取字符串的子串，指定起始位置和截取长度。

如果截取的末尾位置超出字符串长度，截取至字符串末尾。

注意：

1. 该接口返回为字符串的副本，返回的子串使用完后需要手动 free。
2. 如果 beginIndex 等于于字符串长度，或 subLen 等于 0，返回空指针。

参数：

• beginIndex: UIntNative - 截取的起始位置，取值范围为 [0, this.size()]。
• subLen: UIntNative - 截取长度，取值范围为 [0, UIntNative.Max]。

返回值：

• CString - 截取的子串。

异常：

• IndexOutOfBoundsException - 如果 beginIndex 大于字符串长度，抛出异常。
• IllegalMemoryException - 如果内存申请失败或内存拷贝失败时，抛出异常。

示例：

main() {
    let index: UIntNative = 2
    let len: UIntNative = 2
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    var str2: CString = str1.subCString(index, len)
    println(str2)

    unsafe {
        LibC.free(str1)
        LibC.free(str2)
    }
}

输出结果为：

ll

func toString()

public func toString(): String

功能：将 CString 类型转为仓颉的 String 类型。

返回值：

• String - 转换后的字符串。

异常：

• IllegalArgumentException - 不合法的 UTF-8 字节序列。

示例：

main() {
    var str1: CString = unsafe { LibC.mallocCString("hello") }
    println(str1.toString())

    unsafe {
        LibC.free(str1)
    }
}

输出结果为：

hello

Float16

功能：表示 16 位浮点数，符合 IEEE 754 中的半精度格式（binary16）。

extend Float16

extend Float16

功能：拓展半精度浮点数以支持一些数学常数。

static prop Inf

public static prop Inf: Float16

功能：获取半精度浮点数的无穷数。

类型：Float16

static prop Max

public static prop Max: Float16

功能：获取半精度浮点数的最大值。

类型：Float16

static prop Min

public static prop Min: Float16

功能：获取半精度浮点数的最小值。

类型：Float16

static prop MinDenormal

public static prop MinDenormal: Float16

功能：获取半精度浮点数的最小次正规数。最小的正的次正规数是以 IEEE 双精度格式表示的最小正数。

类型：Float16

static prop MinNormal

public static prop MinNormal: Float16

功能：获取半精度浮点数的最小正规数。

类型：Float16

static prop NaN

public static prop NaN: Float16

功能：获取半精度浮点数的非数。

类型：Float16

static func max(Float16, Float16, Array<Float16>)

public static func max(a: Float16, b: Float16, others: Array<Float16>): Float16

功能：返回一组Float16中的最大值，此函数的第三个参数是一个变长参数，可以获取二个以上的Float16最大值，如果参数中有 NaN，该函数会返回 NaN。

参数：

• a: Float16 - 第一个待比较的数。
• b: Float16 - 第二个待比较的数。
• others: Array<Float16> - 其它待比较的数。

返回值：

• Float16 - 返回参数中的最大值。

static func min(Float16, Float16, Array<Float16>)

public static func min(a: Float16, b: Float16, others: Array<Float16>): Float16

功能：返回一组Float16中的最小值，此函数的第三个参数是一个变长参数，可以获取二个以上的Float16最小值，如果参数中有 NaN，该函数会返回 NaN。

参数：

• a: Float16 - 第一个待比较的数。
• b: Float16 - 第一个待比较的数。
• others: Array<Float16> - 其它待比较的数。

返回值：

• Float16 - 返回参数中的最小值。

func isInf()

public func isInf(): Bool

功能：判断某个浮点数 Float16 是否为无穷数值。

返回值：

• Bool - 如果 Float16 的值正无穷大或负无穷大，则返回 true；否则，返回 false。

func isNaN()

public func isNaN(): Bool

功能：判断某个浮点数 Float16 是否为非数值。

返回值：

• Bool - 如果 Float16 的值为非数值，则返回 true；否则，返回 false。

func isNormal()

public func isNormal(): Bool

功能：判断某个浮点数 Float16 是否为常规数值。

返回值：

• Bool - 如果 Float16 的值是正常的浮点数，返回 true；否则，返回 false。

extend Float16 <: Comparable<Float16>

extend Float16 <: Comparable<Float16>

功能：为 Float16 类型扩展 Comparable<Float16> 接口，支持比较操作。

父类型：

• Comparable<Float16>

func compare(Float16)

public func compare(rhs: Float16): Ordering

功能：判断当前 Float16 值与指定 Float16 值的大小关系。

参数：

• rhs: Float16 - 待比较的另一个 Float16 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: Float16 = 0.12
    var num2: Float16 = 0.234
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend Float16

extend Float16

功能：支持与 UInt16 互相转换。

static func fromBits(UInt16)

public static func fromBits(bits: UInt16): Float16

功能：将指定的 UInt16 数转换为 Float16 数。

参数：

• bits: UInt16 - 要转换的数字。

返回值：

• Float16 - 转换结果，其位与参数 bits 值相同。

示例：

main() {
    let v = Float16.fromBits(0x4A40)
    println(v)
}

输出结果为：

12.500000

func toBits()

public func toBits(): UInt16

功能：将指定的 Float16 数转换为以位表示的对应 UInt16 数。

返回值：

• UInt16 - 转换结果，其值与 Float16 的位表示相同。

示例：

main() {
    println(12.5f16.toBits()) //0x4A40 19008
}

输出结果为：

19008

extend Float16 <: Hashable

extend Float16 <: Hashable

功能：为 Float16 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend Float16 <: ToString

extend Float16 <: ToString

功能：为 Float16 类型其扩展 ToString 接口，实现向 String 类型的转换。

默认保留 6 位小数，如需其他精度 String 请参考 Formatter 扩展。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Float16 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

Float32

功能：表示 32 位浮点数，符合 IEEE 754 中的单精度格式（binary32）。

extend Float32

extend Float32

功能：拓展单精度浮点数以支持一些数学常数。

static prop Inf

public static prop Inf: Float32

功能：获取单精度浮点数的无穷数。

类型：Float32

static prop Max

public static prop Max: Float32

功能：获取单精度浮点数的最大值。

类型：Float32

static prop Min

public static prop Min: Float32

功能：获取单精度浮点数的最小值。

类型：Float32

static prop MinDenormal

public static prop MinDenormal: Float32

功能：获取单精度浮点数的最小次正规数。

类型：Float32

static prop MinNormal

public static prop MinNormal: Float32

功能：获取单精度浮点数的最小正规数。

类型：Float32

static prop NaN

public static prop NaN: Float32

功能：获取单精度浮点数的非数。

类型：Float32

static func max(Float32, Float32, Array<Float32>)

public static func max(a: Float32, b: Float32, others: Array<Float32>): Float32

功能：返回一组Float32中的最大值，此函数的第三个参数是一个变长参数，可以获取二个以上的Float32最大值，如果参数中有 NaN，该函数会返回 NaN。

参数：

• a: Float32 - 第一个待比较的数。
• b: Float32 - 第二个待比较的数。
• others: Array<Float32> - 其它待比较的数。

返回值：

• Float32 - 返回参数中的最大值。

static func min(Float32, Float32, Array<Float32>)

public static func min(a: Float32, b: Float32, others: Array<Float32>): Float32

功能：返回一组Float32中的最小值，此函数的第三个参数是一个变长参数，可以获取二个以上的Float32最小值，如果参数中有 NaN，该函数会返回 NaN。

参数：

• a: Float32 - 第一个待比较的数。
• b: Float32 - 第二个待比较的数。
• others: Array<Float32> - 其它待比较的数。

返回值：

• Float32 - 返回参数中的最小值。

func isInf()

public func isInf(): Bool

功能：判断某个浮点数 Float32 是否为无穷数值。

返回值：

• Bool - 如果 Float32 的值正无穷大或负无穷大，则返回 true；否则，返回 false。

func isNaN()

public func isNaN(): Bool

功能：判断某个浮点数 Float32 是否为非数值。

返回值：

• Bool - 如果 Float32 的值为非数值，则返回 true；否则，返回 false。

func isNormal()

public func isNormal(): Bool

功能：判断某个浮点数 Float32 是否为常规数值。

返回值：

• Bool - 如果 Float32 的值是正常的浮点数，返回 true；否则，返回 false。

extend Float32 <: Comparable<Float32>

extend Float32 <: Comparable<Float32>

功能：为 Float32 类型扩展 Comparable<Float32> 接口，支持比较操作。

父类型：

• Comparable<Float32>

func compare(Float32)

public func compare(rhs: Float32): Ordering

功能：判断当前 Float32 值与指定 Float32 值的大小关系。

参数：

• rhs: Float32 - 待比较的另一个 Float32 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: Float32 = 0.12
    var num2: Float32 = 0.234
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend Float32

extend Float32

功能：支持与 UInt32 互相转换。

static func fromBits(UInt32)

public static func fromBits(bits: UInt32): Float32

功能：将指定的 UInt32 类型转换为 Float32 类型。

参数：

• bits: UInt32 - 要转换的数字。

返回值：

• Float32 - 转换结果，其位与参数 bits 值相同。

示例：

main() {
    let v = Float16.fromBits(0x415E147B)
    println(v)
}

输出结果为：

13.880000

func toBits()

public func toBits(): UInt32

功能：将指定的 Float32 数转换为以位表示的对应 UInt32 数。

返回值：

• UInt32 - 转换结果，其值与 Float32 的位表示相同。

示例：

main() {
    println(13.88f32.toBits()) //0x415E147B 1096684667
}

输出结果为：

1096684667

extend Float32 <: Hashable

extend Float32 <: Hashable

功能：为 Float32 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend Float32 <: ToString

extend Float32 <: ToString

功能：为 Float32 类型其扩展 ToString 接口，实现向 String 类型的转换。

默认保留 6 位小数，如需其他精度 String 请参考 Formatter 扩展。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Float32 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

Float64

功能：表示 64 位浮点数，符合 IEEE 754 中的双精度格式（binary64）。

extend Float64

extend Float64

功能：拓展双精度浮点数以支持一些数学常数。

static prop Inf

public static prop Inf: Float64

功能：获取双精度浮点数的无穷数。

类型：Float64

static prop Max

public static prop Max: Float64

功能：获取双精度浮点数的最大值。

类型：Float64

static prop Min

public static prop Min: Float64

功能：获取双精度浮点数的最小值。

类型：Float64

static prop MinDenormal

public static prop MinDenormal: Float64

功能：获取双精度浮点数的最小次正规数。

类型：Float64

static prop MinNormal

public static prop MinNormal: Float64

功能：获取双精度浮点数的最小正规数。

类型：Float64

static prop NaN

public static prop NaN: Float64

功能：获取双精度浮点数的非数。

类型：Float64

static func max(Float64, Float64, Array<Float64>)

public static func max(a: Float64, b: Float64, others: Array<Float64>): Float64

功能：返回一组Float64中的最大值，此函数的第三个参数是一个变长参数，可以获取二个以上的Float64最大值，如果参数中有 NaN，该函数会返回 NaN。

参数：

• a: Float64 - 第一个待比较的数。
• b: Float64 - 第二个待比较的数。
• others: Array<Float64> - 其它待比较的数。

返回值：

• Float64 - 返回参数中的最大值。

static func min(Float64, Float64, Array<Float64>)

public static func min(a: Float64, b: Float64, others: Array<Float64>): Float64

功能：返回一组Float64中的最小值，此函数的第三个参数是一个变长参数，可以获取二个以上的Float64最小值，如果参数中有 NaN，该函数会返回 NaN。

参数：

• a: Float64 - 第一个待比较的数。
• b: Float64 - 第二个待比较的数。
• others: Array<Float64> - 其它待比较的数。

返回值：

• Float64 - 返回参数中的最小值。

func isInf()

public func isInf(): Bool

功能：判断某个浮点数 Float64 是否为无穷数值。

返回值：

• Bool - 如果 Float64 的值正无穷大或负无穷大，则返回 true；否则，返回 false。

func isNaN()

public func isNaN(): Bool

功能：判断某个浮点数 Float64 是否为非数值。

返回值：

• Bool - 如果 Float64 的值为非数值，则返回 true；否则，返回 false。

func isNormal()

public func isNormal(): Bool

功能：判断某个浮点数 Float64 是否为常规数值。

返回值：

• Bool - 如果 Float64 的值是正常的浮点数，返回 true；否则，返回 false。

extend Float64 <: Comparable<Float64>

extend Float64 <: Comparable<Float64>

功能：为 Float64 类型扩展 Comparable<Float64> 接口，支持比较操作。

父类型：

• Comparable<Float64>

func compare(Float64)

public func compare(rhs: Float64): Ordering

功能：判断当前 Float64 值与指定 Float64 值的大小关系。

参数：

• rhs: Float64 - 待比较的另一个 Float64 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: Float64 = 0.12
    var num2: Float64 = 0.234
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend Float64

extend Float64

功能：支持与 UInt64 互相转换。

static func fromBits(UInt64)

public static func fromBits(bits: UInt64): Float64

功能：将指定的 UInt64 数转换为 Float64 数。

参数：

• bits: UInt64 - 要转换的数字。

返回值：

• Float64 - 转换结果，其位与参数 bits 值相同。

示例：

main() {
    let v = Float64.fromBits(0x402BC28F5C28F5C3)
    println(v)
}

输出结果为：

13.880000

func toBits()

public func toBits(): UInt64

功能：将指定的 Float64 数转换为以位表示的对应 UInt64 数。

返回值：

• UInt64 - 转换结果，其值与 Float64 的位表示相同。

示例：

main() {
    println(13.88f64.toBits()) //0x402BC28F5C28F5C3 4624003363408246211
}

输出结果为：

4624003363408246211

extend Float64 <: Hashable

extend Float64 <: Hashable

功能：为 Float64 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend Float64 <: ToString

extend Float64 <: ToString

功能：为 Float64 类型其扩展 ToString 接口，实现向 String 类型的转换。

默认保留 6 位小数，如需其他精度 String 请参考 Formatter 扩展。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Float64 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

Int16

功能：表示 16 位有符号整型，表示范围为 [-2^{15}, 2^{15} - 1]。

extend Int16

extend Int16

功能：拓展 16 位有符号整数以支持一些数学常数。

static prop Max

public static prop Max: Int16

功能：获取 16 位有符号整数的最大值。

类型：Int16

static prop Min

public static prop Min: Int16

功能：获取 16 位有符号整数的最小值。

类型：Int16

extend Int16 <: Comparable<Int16>

extend Int16 <: Comparable<Int16>

功能：为 Int16 类型扩展 Comparable<Int16> 接口，支持比较操作。

父类型：

• Comparable<Int16>

func compare(Int16)

public func compare(rhs: Int16): Ordering

功能：判断当前 Int16 值与指定 Int16 值的大小关系。

参数：

• rhs: Int16 - 待比较的另一个 Int16 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: Int16 = 2
    var num2: Int16 = 3
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend Int16 <: Countable<Int16>

extend Int16 <: Countable<Int16>

功能：为 Int16 类型扩展 Countable<Int16> 接口，支持计数操作。

父类型：

• Countable<Int16>

func next(Int64)

public func next(right: Int64): Int16

功能：获取在数轴上当前 Int16 位置往右移动 right 后对应位置的 Int16 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• Int16 - 往右数 right 后所到位置的 Int16 值。

示例：

main() {
    var num1: Int16 = 32767
    var num2: Int16 = 3
    println(num1.next(5))
    println(num2.next(10))
}

输出结果为：

-32764
13

func position()

public func position(): Int64

功能：获取当前 Int16 值的位置信息，即将该 Int16 转换为 Int64 值。

返回值：

• Int64 - 当前 Int16 值的位置信息。

示例：

main() {
    var num1: Int16 = 32767
    var num2: Int16 = 3
    println(num1.position())
    println(num2.position())
}

输出结果为：

32767
3

extend Int16 <: Hashable

extend Int16 <: Hashable

功能：为 Int16 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend Int16 <: ToString

extend Int16 <: ToString

功能：这里为 Int16 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Int16 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

Int32

功能：表示 32 位有符号整型，表示范围为 [-2^{31}, 2^{31} - 1]。

extend Int32

extend Int32

功能：拓展 32 位有符号整数以支持一些数学常数。

static prop Max

public static prop Max: Int32

功能：获取 32 位有符号整数的最大值。

类型：Int32

static prop Min

public static prop Min: Int32

功能：获取 32 位有符号整数的最小值。

类型：Int32

extend Int32 <: Comparable<Int32>

extend Int32 <: Comparable<Int32>

功能：为 Int32 类型扩展 Comparable<Int32> 接口，支持比较操作。

父类型：

• Comparable<Int32>

func compare(Int32)

public func compare(rhs: Int32): Ordering

功能：判断当前 Int32 值与指定 Int32 值的大小关系。

参数：

• rhs: Int32 - 待比较的另一个 Int32 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: Int32 = 8
    var num2: Int32 = 10
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend Int32 <: Countable<Int32>

extend Int32 <: Countable<Int32>

功能：为 Int32 类型扩展 Countable<Int32> 接口，支持计数操作。

父类型：

• Countable<Int32>

func next(Int64)

public func next(right: Int64): Int32

功能：获取在数轴上当前 Int32 位置往右移动 right 后对应位置的 Int32 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• Int32 - 往右数 right 后所到位置的 Int32 值。

示例：

main() {
    var num: Int32 = 3
    println(num.next(10))
}

输出结果为：

13

func position()

public func position(): Int64

功能：获取当前 Int32 值的位置信息，即将该 Int32 转换为 Int64 值。

返回值：

• Int64 - 当前 Int32 值的位置信息。

示例：

main() {
    var num: Int32 = 3
    println(num.position())
}

输出结果为：

3

extend Int32 <: Hashable

extend Int32 <: Hashable

功能：为 Int32 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend Int32 <: ToString

extend Int32 <: ToString

功能：这里为 Int32 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Int32 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

Int64

功能：表示 64 位有符号整型，表示范围为 [-2^{63}, 2^{63} - 1]。

extend Int64

extend Int64

功能：拓展 64 位有符号整数以支持一些数学常数。

static prop Max

public static prop Max: Int64

功能：获取 64 位有符号整数的最大值。

类型：Int64

static prop Min

public static prop Min: Int64

功能：获取 64 位有符号整数的最小值。

类型：Int64

extend Int64 <: Comparable<Int64>

extend Int64 <: Comparable<Int64>

功能：为 Int64 类型扩展 Comparable<Int64> 接口，支持比较操作。

父类型：

• Comparable<Int64>

func compare(Int64)

public func compare(rhs: Int64): Ordering

功能：判断当前 Int64 值与指定 Int64 值的大小关系。

参数：

• rhs: Int64 - 待比较的另一个 Int64 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ 如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: Int64 = 2
    var num2: Int64 = 3
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend Int64 <: Countable<Int64>

extend Int64 <: Countable<Int64>

功能：为 Int64 类型扩展 Countable<Int64> 接口，支持计数操作。

父类型：

• Countable<Int64>

func next(Int64)

public func next(right: Int64): Int64

功能：获取在数轴上当前 Int64 位置往右移动 right 后对应位置的 Int64 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• Int64 - 往右数 right 后所到位置的 Int64 值。

示例：

main() {
    var num: Int64 = 3
    println(num.next(10))
}

输出结果为：

13

func position()

public func position(): Int64

功能：获取当前 Int64 值的位置信息，即返回该 Int64 值本身。

返回值：

• Int64 - 当前 Int64 值的位置信息。

示例：

main() {
    var num: Int64 = 3
    println(num.position())
}

输出结果为：

3

extend Int64 <: Hashable

extend Int64 <: Hashable

功能：为 Int64 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend Int64 <: ToString

extend Int64 <: ToString

功能：这里为 Int64 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Int64 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

Int8

功能：表示 8 位有符号整型，表示范围为 [-2^7, 2^7 - 1]。

extend Int8

extend Int8

功能：拓展 8 位有符号整数以支持一些数学常数。

static prop Max

public static prop Max: Int8

功能：获取 8 位有符号整数的最大值。

类型：Int8

static prop Min

public static prop Min: Int8

功能：获取 8 位有符号整数的最小值。

类型：Int8

extend Int8 <: Comparable<Int8>

extend Int8 <: Comparable<Int8>

功能：为 Int8 类型扩展 Comparable<Int8> 接口，支持比较操作。

父类型：

• Comparable<Int8>

func compare(Int8)

public func compare(rhs: Int8): Ordering

功能：判断当前 Int8 值与指定 Int8 值的大小关系。

参数：

• rhs: Int8 - 待比较的另一个 Int8 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: Int8 = 2
    var num2: Int8 = 3
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend Int8 <: Countable<Int8>

extend Int8 <: Countable<Int8>

功能：为 Int8 类型扩展 Countable<Int8> 接口，支持计数操作。

父类型：

• Countable<Int8>

func next(Int64)

public func next(right: Int64): Int8

功能：获取在数轴上当前 Int8 位置往右移动 right 后对应位置的 Int8 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• Int8 - 往右数 right 后所到位置的 Int8 值。

示例：

main() {
    var num: Int8 = 3
    println(num.next(5))
}

输出结果为：

8

func position()

public func position(): Int64

功能：获取当前 Int8 值的位置信息，即将该 Int8 转换为 Int64 值。

返回值：

• Int64 - 当前 Int8 值的位置信息。

示例：

main() {
    var num: Int8 = 3
    println(num.position())
}

输出结果为：

3

extend Int8 <: Hashable

extend Int8 <: Hashable

功能：为 Int8 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend Int8 <: ToString

extend Int8 <: ToString

功能：这里为 Int8 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Int8 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

IntNative

功能：表示平台相关的有符号整型，其长度与当前系统的位宽一致。

extend IntNative

extend IntNative

功能：拓展平台相关有符号整数以支持一些数学常数。

static prop Max

public static prop Max: IntNative

功能：获取平台相关有符号整数的最大值。

类型：IntNative

static prop Min

public static prop Min: IntNative

功能：获取平台相关有符号整数的最小值。

类型：IntNative

extend IntNative <: Comparable<IntNative>

extend IntNative <: Comparable<IntNative>

功能：为 IntNative 类型扩展 Comparable<IntNative> 接口，支持比较操作。

父类型：

• Comparable<IntNative>

func compare(IntNative)

public func compare(rhs: IntNative): Ordering

功能：判断当前 IntNative 值与指定 IntNative 值的大小关系。

参数：

• rhs: IntNative - 待比较的另一个 IntNative 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: IntNative = 8
    var num2: IntNative = 10
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend IntNative <: Countable<IntNative>

extend IntNative <: Countable<IntNative>

功能：为 IntNative 类型扩展 Countable<IntNative> 接口，支持计数操作。

父类型：

• Countable<IntNative>

func next(Int64)

public func next(right: Int64): IntNative

功能：获取在数轴上当前 IntNative 位置往右移动 right 后对应位置的 IntNative 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• IntNative - 往右数 right 后所到位置的 IntNative 值。

示例：

main() {
    var num: IntNative = 8
    println(num.next(4))
}

输出结果为：

12

func position()

public func position(): Int64

功能：获取当前 IntNative 值的位置信息，即将该 IntNative 转换为 Int64 值。

返回值：

• Int64 - 当前 IntNative 值的位置信息。

示例：

main() {
    var num: IntNative = 8
    println(num.position())
}

输出结果为：

8

extend IntNative <: Hashable

extend IntNative <: Hashable

功能：为 IntNative 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend IntNative <: ToString

extend IntNative <: ToString

功能：这里为 IntNative 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 IntNative 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

Rune

功能：表示 unicode 字符集中的字符。

表示范围为 Unicode scalar value，即从 \u{0000} 到 \u{D7FF}，以及从 \u{E000} 到 \u{10FFF} 的字符。

extend Rune

extend Rune

功能：为 Rune 类型实现一系列扩展方法，主要为在 Ascii 字符集范围内的一些字符判断、转换等操作。

static func fromUtf8(Array<UInt8>, Int64)

public static func fromUtf8(arr: Array<UInt8>, index: Int64): (Rune, Int64)

功能：将字节数组中的指定元素，根据 UTF-8 编码规则转换成字符，并告知字符占用字节长度。

参数：

• arr: Array<UInt8> - 待转换字节所在的字节数组。
• index: Int64 - 待转换字节在数组中的下标。

返回值：

• (Rune, Int64) - 转换得到的字符，以及该字符占用的字节长度。

异常：

• IllegalArgumentException - 不合法的 UTF-8 字节序列。

示例：

main() {
    var arr: Array<UInt8> = [4u8, 8u8, 65u8] // A <=> 65
    var tuple = Rune.fromUtf8(arr, 2)
    println(tuple[0]) // Rune
    println(tuple[1]) // len
}

输出结果为：

A
1

static func getPreviousFromUtf8(Array<UInt8>, Int64)

public static func getPreviousFromUtf8(arr: Array<UInt8>, index: Int64): (Rune, Int64)

功能：获取字节数组中指定索引对应的字节所在的 UTF-8 编码字符，同时返回该字符首位字节码在数组中的索引。

当指定了一个索引，那么函数会找到数组对应索引位置并且根据 UTF-8 规则，查看该字节码是否是字符的首位字节码，如果不是就继续向前遍历，直到该字节码是首位字节码，然后利用字节码序列找到对应的字符。

参数：

• arr: Array<UInt8> - 待从中获取字符的字节数组。
• index: Int64 - 待查找字符在数组中的索引。

返回值：

• (Rune, Int64) - 找到的字符，以及该字符首位字节码在数组中的索引。

异常：

• IllegalArgumentException - 如果找不到对应首位字节码，即指定字节所在位置的字节不符合 UTF-8 编码，抛出异常。

static func intoUtf8Array(Rune, Array<UInt8>, Int64)

public static func intoUtf8Array(c: Rune, arr: Array<UInt8>, index: Int64): Int64

功能：该函数会把字符转成字节码序列然后覆盖 Array 数组内指定位置的字节码。

参数：

• c: Rune - 待转换的字符。
• arr: Array<UInt8> - 待覆盖的 Array 数组。
• index: Int64 - 目标位置的起始索引。

返回值：

• Int64 - 字符的字节码长度，例如中文是三个字节码长度。

示例：

main() {
    var arr: Array<UInt8> = [ 1u8, 2u8, 3u8, 230u8, 136u8, 145u8] 
    var len: Int64 = Rune.intoUtf8Array(r'爱', arr, 2)
    println(len)
    println(arr[2]) //字符爱的utf-8编码的第一个字节
}

输出结果为：

3
231

static func utf8Size(Array<UInt8>, Int64)

public static func utf8Size(arr: Array<UInt8>, index: Int64): Int64

功能：该函数会返回字节数组指定索引位置为起始的字符占用的字节数。

在 UTF-8 编码中，ASCII 码首位字节第一位不为 1，其他长度的字符首位字节开头 1 的个数表明了该字符对应的字节码长度，该函数通过扫描首位，判断字节码长度。如果索引对应的不是首位字节码，就会抛出异常。

参数：

• arr: Array<UInt8> - 待获取字符的字节数组。
• index: Int64 - 指定字符的索引。

返回值：

• Int64 - 字符的字节码长度，例如中文是三个字节码长度。

异常：

• IllegalArgumentException - 如果索引位置的字节码不符合首位字节码规则，会抛出异常。

示例：

main() {
    var arr: Array<UInt8> = [ 1u8, 2u8, 231u8, 136u8, 177u8, 145u8] 
    var len: Int64 = Rune.utf8Size(arr, 2)
    println(len) //索引为2-4的数组元素为中文字符爱的utf-8编码，占用三字节
}

输出结果为：

3

static func utf8Size(Rune)

public static func utf8Size(c: Rune): Int64

功能：返回字符对应的 UTF-8 编码的字节码长度，例如中文字符的字节码长度是 3。

参数：

• c: Rune - 待计算 UTF-8 字节码长度的字符。

返回值：

• Int64 - 字符的 UTF-8 字节码长度。

示例：

main() {
    var char: Rune = r'爱' 
    var len: Int64 = Rune.utf8Size(char)
    println(len) //中文字符爱的utf-8编码，占用三字节
}

输出结果为：

3

func isAscii()

public func isAscii(): Bool

功能：判断字符是否是 Ascii 中的字符。

返回值：

• Bool - 如果是 Ascii 字符返回 true，否则返回 false。

func isAsciiControl()

public func isAsciiControl(): Bool

功能：判断字符是否是 Ascii 控制字符。其取值范围为 [00, 1F] 和 {7F} 的并集。

返回值：

• Bool - 如果是 Ascii 控制字符返回 true，否则返回 false。

func isAsciiGraphic()

public func isAsciiGraphic(): Bool

功能：判断字符是否是 Ascii 图形字符。其取值范围为 [21, 7E]。

返回值：

• Bool - 如果是 Ascii 图形字符返回 true，否则返回 false。

func isAsciiHex()

public func isAsciiHex(): Bool

功能：判断字符是否是 Ascii 十六进制字符。

返回值：

• Bool - 如果是 Ascii 十六进制字符返回 true，否则返回 false。

func isAsciiLetter()

public func isAsciiLetter(): Bool

功能：判断字符是否是 Ascii 字母字符。

返回值：

• Bool - 如果是 Ascii 字母字符返回 true，否则返回 false。

func isAsciiLowerCase()

public func isAsciiLowerCase(): Bool

功能：判断字符是否是 Ascii 小写字符。

返回值：

• Bool - 如果是 Ascii 小写字符返回 true，否则返回 false。

func isAsciiNumber()

public func isAsciiNumber(): Bool

功能：判断字符是否是 Ascii 数字字符。

返回值：

• Bool - 如果是 Ascii 数字字符返回 true，否则返回 false。

func isAsciiNumberOrLetter()

public func isAsciiNumberOrLetter(): Bool

功能：判断字符是否是 Ascii 数字或拉丁字母字符。

返回值：

• Bool - 如果是 Ascii 数字或拉丁字母字符返回 true，否则返回 false。

func isAsciiOct()

public func isAsciiOct(): Bool

功能：判断字符是否是 Ascii 八进制字符。

返回值：

• Bool - 如果是 Ascii 八进制字符返回 true，否则返回 false。

func isAsciiPunctuation()

public func isAsciiPunctuation(): Bool

功能：判断字符是否是 Ascii 标点符号字符。其取值范围为 [21, 2F]、[3A, 40]、[5B, 60] 和 [7B, 7E] 的并集。

返回值：

• Bool - 如果是 Ascii 标点符号字符返回 true，否则返回 false。

func isAsciiUpperCase()

public func isAsciiUpperCase(): Bool

功能：判断字符是否是 Ascii 大写字符。

返回值：

• Bool - 如果是 Ascii 大写字符返回 true，否则返回 false。

func isAsciiWhiteSpace()

public func isAsciiWhiteSpace(): Bool

功能：判断字符是否是 Ascii 空白字符。其取值范围为 [09, 0D] 和 {20} 的并集。

返回值：

• Bool - 如果是 Ascii 空白字符返回 true，否则返回 false。

func toAsciiLowerCase()

public func toAsciiLowerCase(): Rune

功能：将字符转换为 Ascii 小写字符，如果无法转换则保持现状。

返回值：

• Rune - 转换后的字符，如果无法转换则返回原来的 Rune。

func toAsciiUpperCase()

public func toAsciiUpperCase(): Rune

功能：将字符转换为 Ascii 大写字符，如果无法转换则保持现状。

返回值：

• Rune - 转换后的字符，如果无法转换则返回原来的 Rune。

extend Rune <: Comparable<Rune>

extend Rune <: Comparable<Rune>

功能：为 Rune 类型扩展 Comparable<Rune> 接口，支持比较操作。

父类型：

• Comparable<Rune>

func compare(Rune)

public func compare(rhs: Rune): Ordering

功能：判断当前 Rune 实例与指定 Rune 实例的大小关系。

Rune 的大小关系指的是它们对应的 unicode 码点的大小关系。

参数：

• rhs: Rune - 待比较的另一个 Rune 实例。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var char1: Rune = r'i' 
    var char2: Rune = r'j'
    println(char1.compare(char2))
}

输出结果为：

Ordering.LT

extend Rune <: Countable<Rune>

extend Rune <: Countable<Rune>

功能：为 Rune 类型扩展 Countable<Rune> 接口，支持计数操作。

父类型：

• Countable<Rune>

func next(Int64)

public func next(right: Int64): Rune

功能：获取当前 Rune 值往右数 right 后所到位置的 Rune 值。

参数：

• right: Int64 - 往右数的个数。

返回值：

• Rune - 往右数 right 后所到位置的 Rune 值。

异常：

• OverflowException - 如果与 Int64 数进行加法运算后为不合法的 Unicode 值，抛出异常。

func position()

public func position(): Int64

功能：获取当前 Rune 值的位置信息，即将该 Rune 转换为 Int64 值。

返回值：

• Int64 - 当前 Rune 值的位置信息。

extend Rune <: Hashable

extend Rune <: Hashable

功能：为 Rune 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend Rune <: ToString

extend Rune <: ToString

功能：这里为 Rune 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Rune 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

UInt16

功能：表示 16 位无符号整型，表示范围为 [0, 2^{16} - 1]。

extend UInt16

extend UInt16

功能：拓展 16 位无符号整数以支持一些数学常数。

static prop Max

public static prop Max: UInt16

功能：获取 16 位无符号整数的最大值。

类型：UInt16

static prop Min

public static prop Min: UInt16

功能：获取 16 位无符号整数的最小值。

类型：UInt16

extend UInt16 <: Comparable<UInt16>

extend UInt16 <: Comparable<UInt16>

功能：为 UInt16 类型扩展 Comparable<UInt16> 接口，支持比较操作。

父类型：

• Comparable<UInt16>

func compare(UInt16)

public func compare(rhs: UInt16): Ordering

功能：判断当前 UInt16 值与指定 UInt16 值的大小关系。

参数：

• rhs: UInt16 - 待比较的另一个 UInt16 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: UInt16 = 2
    var num2: UInt16 = 3
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend UInt16 <: Countable<UInt16>

extend UInt16 <: Countable<UInt16>

功能：为 UInt16 类型扩展 Countable<UInt16> 接口，支持计数操作。

父类型：

• Countable<UInt16>

func next(Int64)

public func next(right: Int64): UInt16

功能：获取在数轴上当前 UInt16 位置往右移动 right 后对应位置的 UInt16 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• UInt16 - 往右数 right 后所到位置的 UInt16 值。

示例：

main() {
    var num: UInt16 = 3
    println(num.next(10))
}

输出结果为：

13

func position()

public func position(): Int64

功能：获取当前 UInt16 值的位置信息，即将该 UInt16 转换为 Int64 值。

返回值：

• Int64 - 当前 UInt16 值的位置信息。

示例：

main() {
    var num: UInt16 = 8
    println(num.position())
}

输出结果为：

8

extend UInt16 <: Hashable

extend UInt16 <: Hashable

功能：为 UInt16 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend UInt16 <: ToString

extend UInt16 <: ToString

功能：这里为 UInt16 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 UInt16 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

UInt32

功能：表示 32 位无符号整型，表示范围为 [0, 2^{32} - 1]。

extend UInt32

extend UInt32

功能：拓展 32 位无符号整数以支持一些数学常数。

static prop Max

public static prop Max: UInt32

功能：获取 32 位无符号整数的最大值。

类型：UInt32

static prop Min

public static prop Min: UInt32

功能：获取 32 位无符号整数的最小值。

类型：UInt32

extend UInt32 <: Comparable<UInt32>

extend UInt32 <: Comparable<UInt32>

功能：为 UInt32 类型扩展 Comparable<UInt32> 接口，支持比较操作。

父类型：

• Comparable<UInt32>

func compare(UInt32)

public func compare(rhs: UInt32): Ordering

功能：判断当前 UInt32 值与指定 UInt32 值的大小关系。

参数：

• rhs: UInt32 - 待比较的另一个 UInt32 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: UInt32 = 2
    var num2: UInt32 = 3
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend UInt32 <: Countable<UInt32>

extend UInt32 <: Countable<UInt32>

功能：为 UInt32 类型扩展 Countable<UInt32> 接口，支持计数操作。

父类型：

• Countable<UInt32>

func next(Int64)

public func next(right: Int64): UInt32

功能：获取在数轴上当前 UInt32 位置往右移动 right 后对应位置的 UInt32 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• UInt32 - 往右数 right 后所到位置的 UInt32 值。

示例：

main() {
    var num: UInt32 = 3
    println(num.next(10))
}

输出结果为：

13

func position()

public func position(): Int64

功能：获取当前 UInt32 值的位置信息，即将该 UInt32 转换为 UInt64 值。

返回值：

• Int64 - 当前 UInt32 值的位置信息。

示例：

main() {
    var num: UInt32 = 8
    println(num.position())
}

输出结果为：

8

extend UInt32 <: Hashable

extend UInt32 <: Hashable

功能：为 UInt32 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend UInt32 <: ToString

extend UInt32 <: ToString

功能：这里为 UInt32 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 UInt32 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

UInt64

功能：表示 64 位无符号整型，表示范围为 [0, 2^{64} - 1]。

extend UInt64

extend UInt64

功能：拓展 64 位无符号整数以支持一些数学常数。

static prop Max

public static prop Max: UInt64

功能：获取 64 位无符号整数的最大值。

类型：UInt64

static prop Min

public static prop Min: UInt64

功能：获取 64 位无符号整数的最小值。

类型：UInt64

extend UInt64 <: Comparable<UInt64>

extend UInt64 <: Comparable<UInt64>

功能：为 UInt64 类型扩展 Comparable<UInt64> 接口，支持比较操作。

父类型：

• Comparable<UInt64>

func compare(UInt64)

public func compare(rhs: UInt64): Ordering

功能：判断当前 UInt64 值与指定 UInt64 值的大小关系。

参数：

• rhs: UInt64 - 待比较的另一个 UInt64 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: UInt64 = 2
    var num2: UInt64 = 3
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend UInt64 <: Countable<UInt64>

extend UInt64 <: Countable<UInt64>

功能：为 UInt64 类型扩展 Countable<UInt64> 接口，支持计数操作。

父类型：

• Countable<UInt64>

func next(Int64)

public func next(right: Int64): UInt64

功能：获取在数轴上当前 UInt64 位置往右移动 right 后对应位置的 UInt64 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• UInt64 - 往右数 right 后所到位置的 UInt64 值。

示例：

main() {
    var num: UInt64 = 3
    println(num.next(10))
}

输出结果为：

13

func position()

public func position(): Int64

功能：获取当前 UInt64 值的位置信息，即将该 UInt64 转换为 Int64 值。

返回值：

• Int64 - 当前 UInt64 值的位置信息。

示例：

main() {
    var num: UInt64 = 8
    println(num.position())
}

输出结果为：

8

extend UInt64 <: Hashable

extend UInt64 <: Hashable

功能：为 UInt64 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend UInt64 <: ToString

extend UInt64 <: ToString

功能：这里为 UInt64 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 UInt64 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

UInt8

功能：表示 8 位无符号整型，表示范围为 [0, 2^8 - 1]。

extend UInt8

extend UInt8

功能：拓展 8 位无符号整数以支持一些数学常数。

static prop Max

public static prop Max: UInt8

功能：获取 8 位无符号整数的最大值。

类型：UInt8

static prop Min

public static prop Min: UInt8

功能：获取 8 位无符号整数的最小值。

类型：UInt8

extend UInt8 <: Comparable<UInt8>

extend UInt8 <: Comparable<UInt8>

功能：为 UInt8 类型扩展 Comparable<UInt8> 接口，支持比较操作。

父类型：

• Comparable<UInt8>

func compare(UInt8)

public func compare(rhs: UInt8): Ordering

功能：判断当前 UInt8 值与指定 UInt8 值的大小关系。

参数：

• rhs: UInt8 - 待比较的另一个 UInt8 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: UInt8 = 2
    var num2: UInt8 = 3
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend UInt8 <: Countable<UInt8>

extend UInt8 <: Countable<UInt8>

功能：为 UInt8 类型扩展 Countable<UInt8> 接口，支持计数操作。

父类型：

• Countable<UInt8>

func next(Int64)

public func next(right: Int64): UInt8

功能：获取在数轴上当前 UInt8 位置往右移动 right 后对应位置的 UInt8 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• UInt8 - 往右数 right 后所到位置的 UInt8 值。

示例：

main() {
    var num: UInt8 = 3
    println(num.next(10))
}

输出结果为：

13

func position()

public func position(): Int64

功能：获取当前 UInt8 值的位置信息，即将该 UInt8 转换为 Int64 值。

返回值：

• Int64 - 当前 UInt8 值的位置信息。

示例：

main() {
    var num: UInt8 = 8
    println(num.position())
}

输出结果为：

8

extend UInt8 <: Hashable

extend UInt8 <: Hashable

功能：为 UInt8 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend UInt8 <: ToString

extend UInt8 <: ToString

功能：这里为 UInt8 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 UInt8 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

UIntNative

功能：表示平台相关的无符号整型，其长度与当前系统的位宽一致。

extend UIntNative

extend UIntNative

功能：拓展平台相关无符号整数以支持一些数学常数。

static prop Max

public static prop Max: UIntNative

功能：获取平台相关无符号整数的最大值。

类型：类型：UIntNative

static prop Min

public static prop Min: UIntNative

功能：获取平台相关无符号整数的最小值。

类型：UIntNative

extend UIntNative <: Comparable<UIntNative>

extend UIntNative <: Comparable<UIntNative>

功能：为 UIntNative 类型扩展 Comparable<UIntNative> 接口，支持比较操作。

父类型：

• Comparable<UIntNative>

func compare(UIntNative)

public func compare(rhs: UIntNative): Ordering

功能：判断当前 UIntNative 值与指定 UIntNative 值的大小关系。

参数：

• rhs: UIntNative - 待比较的另一个 UIntNative 值。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

示例：

main() {
    var num1: UIntNative = 2
    var num2: UIntNative = 3
    println(num1.compare(num2))
}

输出结果为：

Ordering.LT

extend UIntNative <: Countable

extend UIntNative <: Countable<UIntNative>

功能：为 UIntNative 类型扩展 Countable<UIntNative> 接口，支持计数操作。

父类型：

• Countable<UIntNative>

func next(Int64)

public func next(right: Int64): UIntNative

功能：获取在数轴上当前 UIntNative 位置往右移动 right 后对应位置的 UIntNative 值。如果值溢出，则会从数轴最左边继续移动。

参数：

• right: Int64 - 往右数的个数。

返回值：

• UIntNative - 往右数 right 后所到位置的 UIntNative 值。

示例：

main() {
    var num: UIntNative = 3
    println(num.next(10))
}

输出结果为：

13

func position()

public func position(): Int64

功能：获取当前 UIntNative 值的位置信息，即将该 UIntNative 转换为 Int64 值。

返回值：

• Int64 - 当前 UIntNative 值的位置信息。

示例：

main() {
    var num: UIntNative = 8
    println(num.position())
}

输出结果为：

8

extend UIntNative <: Hashable

extend UIntNative <: Hashable

功能：为 UIntNative 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend UIntNative <: ToString

extend UIntNative <: ToString

功能：这里为 UIntNative 类型扩展 ToString 接口，实现向 String 类型的转换。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 UIntNative 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

Unit

功能：表示仓颉语言中只关心副作用而不关心值的表达式的类型。

例如，print 函数、赋值表达式、复合赋值表达式、自增和自减表达式、循环表达式，它们的类型都是 Unit。

Unit 类型只有一个值，也是它的字面量：()。除了赋值、判等和判不等外，Unit 类型不支持其他操作。

extend Unit <: Equatable<Unit>

extend Unit <: Equatable<Unit>

功能：为 Unit 类型扩展 Equatable<Unit> 接口。

父类型：

• Equatable<Unit>

extend Unit <: Hashable

extend Unit <: Hashable

功能：为 Unit 类型扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值，Unit 的哈希值为 0。

返回值：

• Int64 - 哈希值。

extend Unit <: ToString

extend Unit <: ToString

功能：为 Unit 类型其扩展 ToString 接口，实现向 String 类型的转换。

Unit 的字符串表示是 "()"。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Unit 值转换为可输出的字符串。

返回值：

• String - 转化后的字符串。

接口

interface Any

public interface Any

功能：Any 是所有类型的父类型，所有 interface 都默认继承它，所有非 interface 类型都默认实现它。

extend Byte

extend Byte

功能：为 Byte 类型实现一系列扩展方法，主要为在 Ascii 字符集范围内的一些字符判断、转换等操作。

func isAscii()

public func isAscii(): Bool

功能：判断 Byte 是否是在 Ascii 范围内。

返回值：

• Bool - 如果 Byte 在 Ascii 范围内返回 true，否则返回 false。

func isAsciiControl()

public func isAsciiControl(): Bool

功能：判断 Byte 是否是在 Ascii 控制字符范围内。其取值范围为 [00, 1F] 和 {7F} 的并集。

返回值：

• Bool - 如果 Byte 在 Ascii 控制字符范围内返回 true，否则返回 false。

func isAsciiGraphic()

public func isAsciiGraphic(): Bool

功能：判断 Byte 是否是在 Ascii 图形字符范围内。其取值范围为 [21, 7E]。

返回值：

• Bool - 如果 Byte 在 Ascii 图形字符范围内返回 true，否则返回 false。

func isAsciiHex()

public func isAsciiHex(): Bool

功能：判断 Byte 是否是在 Ascii 十六进制数字范围内。

返回值：

• Bool - 如果 Byte 在 Ascii 十六进制数字范围内返回 true，否则返回 false。

func isAsciiLetter()

public func isAsciiLetter(): Bool

功能：判断 Byte 是否是在 Ascii 拉丁字母范围内。

返回值：

• Bool - 如果 Byte 在 Ascii 拉丁字母范围内返回 true，否则返回 false。

func isAsciiLowerCase()

public func isAsciiLowerCase(): Bool

功能：判断 Byte 是否是在 Ascii 小写拉丁字母范围内。

返回值：

• Bool - 如果 Byte 在 Ascii 小写拉丁字母范围内返回 true，否则返回 false。

func isAsciiNumber()

public func isAsciiNumber(): Bool

功能：判断 Byte 是否是在 Ascii 十进制数字范围内。

返回值：

• Bool - 如果 Byte 在 Ascii 十进制数字范围内返回 true，否则返回 false。

func isAsciiNumberOrLetter()

public func isAsciiNumberOrLetter(): Bool

功能：判断 Byte 是否是在 Ascii 十进制数字和拉丁字母范围内。

返回值：

• Bool - 如果 Byte 在 Ascii 十进制数字和拉丁字母范围内返回 true，否则返回 false。

func isAsciiOct()

public func isAsciiOct(): Bool

功能：判断 Byte 是否是在 Ascii 八进制数字范围内。

返回值：

• Bool - 如果 Byte 在 Ascii 八进制数字范围内返回 true，否则返回 false。

func isAsciiPunctuation()

public func isAsciiPunctuation(): Bool

功能：判断 Byte 是否是在 Ascii 标点符号范围内。其取值范围为 [21, 2F]、[3A, 40]、[5B, 60] 和 [7B, 7E] 的并集。

返回值：

• Bool - 如果 Byte 在 Ascii 标点符号范围内返回 true，否则返回 false。

func isAsciiUpperCase()

public func isAsciiUpperCase(): Bool

功能：判断 Byte 是否是在 Ascii 大写拉丁字母范围内。

返回值：

• Bool - 如果 Byte 在 Ascii 大写拉丁字母范围内返回 true，否则返回 false。

func isAsciiWhiteSpace()

public func isAsciiWhiteSpace(): Bool

功能：判断 Byte 是否是在 Ascii 空白字符范围内。其取值范围为 [09, 0D] 和 {20} 的并集。

返回值：

• Bool - 如果 Byte 在 Ascii 空白字符范围内返回 true，否则返回 false。

func toAsciiLowerCase()

public func toAsciiLowerCase(): Byte

功能：将 Byte 换为对应的 Ascii 小写字符 Byte，如果无法转换则保持现状。

返回值：

• Byte - 转换后的 Byte，如果无法转换则返回原来的 Byte。

func toAsciiUpperCase()

public func toAsciiUpperCase(): Byte

功能：将 Byte 换为对应的 Ascii 大写字符 Byte，如果无法转换则保持现状。

返回值：

• Byte - 转换后的 Byte，如果无法转换则返回原来的 Byte。

interface CType

sealed interface CType

功能：表示支持与 C 语言互操作的接口。

CType 接口是一个语言内置的空接口，它是 CType 约束的具体实现，所有 C 互操作支持的类型都隐式地实现了该接口，因此所有 C 互操作支持的类型都可以作为 CType 类型的子类型使用。

注意：

• CType 接口是仓颉中的一个接口类型，它本身不满足 CType 约束。
• CType 接口不允许被用户继承、扩展。
• CType 接口不会突破子类型的使用限制。

示例：

@C
struct Data {}

@C
func foo() {}

main() {
    var c: CType = Data() // ok
    c = 0 // ok
    c = true // ok
    c = CString(CPointer<UInt8>()) // ok
    c = CPointer<Int8>() // ok
    c = foo // ok
}

interface Collection<T>

public interface Collection<T> <: Iterable<T> {
    prop size: Int64
    func isEmpty(): Bool
    func toArray(): Array<T>
}

功能：该接口用来表示集合，通常容器类型应该实现该接口。

父类型：

• Iterable<T>

prop size

prop size: Int64

功能：获取当前集合的大小，即集合中元素的个数。

类型：Int64

func isEmpty()

func isEmpty(): Bool

功能：判断当前集合是否为空。

返回值：

• Bool - 如果为空返回 true，否则返回 false。

func toArray()

func toArray(): Array<T>

功能：将当前集合转为数组类型。

返回值：

• Array<T> - 转换得到的数组。

interface Comparable<T>

public interface Comparable<T> <: Equatable<T> & Less<T> & Greater<T> & LessOrEqual<T> & GreaterOrEqual<T> {
    func compare(that: T): Ordering
    operator func <(rhs: T): Bool
    operator func <=(rhs: T): Bool
    operator func ==(rhs: T): Bool
    operator func >(rhs: T): Bool
    operator func >=(rhs: T): Bool
}

功能：该接口表示比较运算，是等于、不等于、小于、大于、小于等于、大于等于接口的集合体。

该接口中提供运算符 ==、!=、<、<=、>、>= 重载的默认实现，默认实现根据 compare 函数的返回值来确定其返回值。例如：如果 a.compare(b) 的返回值为 EQ，则 a == b 返回 true，否则返回 false。

父类型：

• Equatable<T>
• Less<T>
• Greater<T>
• LessOrEqual<T>
• GreaterOrEqual<T>

func compare(T)

func compare(that: T): Ordering

功能：判断当前 T 类型实例与参数指向的 T 类型实例的大小关系。

参数：

• that: T - 待与当前实例比较的另一个实例。

返回值：

• Ordering - 如果大于，返回 Ordering.GT，如果等于，返回 Ordering.EQ，如果小于，返回 Ordering.LT。

operator func <(T)

operator func <(rhs: T): Bool

功能：判断当前 T 类型实例是否小于参数指向的 T 类型实例，该函数是此接口的一个默认实现函数。

参数：

• rhs: T - 待与当前实例比较的另一个实例。

返回值：

• Bool - 如果小于，返回 true，否则返回 false。

operator func <=(T)

operator func <=(rhs: T): Bool

功能：判断当前 T 类型实例是否小于等于参数指向的 T 类型实例，该函数是此接口的一个默认实现函数。

参数：

• rhs: T - 待与当前实例比较的另一个实例。

返回值：

• Bool - 如果小于等于，返回 true，否则返回 false。

operator func ==(T)

operator func ==(rhs: T): Bool

功能：判断两个实例是否相等，该函数是此接口的一个默认实现函数。

参数：

• rhs: T - 待比较的另一个实例。

返回值：

• Bool - 如果相等，返回 true，否则返回 false。

operator func >(T)

operator func >(rhs: T): Bool

功能：判断当前 T 类型实例是否大于参数指向的 T 类型实例，该函数是此接口的一个默认实现函数。

参数：

• rhs: T - 待与当前实例比较的另一个实例。

返回值：

• Bool - 如果大于，返回 true，否则返回 false。

operator func >=(T)

operator func >=(rhs: T): Bool

功能：判断当前 T 类型实例是否大于等于参数指向的 T 类型实例，该函数是此接口的一个默认实现函数。

参数：

• rhs: T - 待与当前实例比较的另一个实例。

返回值：

• Bool - 如果大于等于，返回 true，否则返回 false。

interface Countable<T>

public interface Countable<T> {
    func next(right: Int64): T
    func position(): Int64
}

功能：该接口表示类型可数。

可数类型的每一个实例都对应一个位置信息（Int64 值），可以通过往后数数得到其他的该类型实例。

func next(Int64)

func next(right: Int64): T

功能：获取当前实例向右移动 right 后对应位置的 T 类型实例。

参数：

• right: Int64 - 往右数的个数。

返回值：

• T - 向右移动 right 后对应位置的 T 类型实例。

func position()

func position(): Int64

功能：获取当前可数实例的位置信息，即将当前实例转为 Int64 类型。

返回值：

• Int64 - 转换后的 Int64 值。

extend Float64

extend Float64

功能：拓展了 Float64 类型作为左操作数和 Duration 类型作为右操作数的乘法运算。

operator func *(Duration)

public operator func *(r: Duration): Duration

功能：实现 Float64 类型和 Duration 类型的乘法，即 Float64 * Duration 运算。

参数：

• r: Duration - Duration 实例。

返回值：

• Duration - Float64 类型实例和 r 的乘积。

异常：

• ArithmeticException - 当相乘后的结果超出 Duration 的表示范围时，抛出异常。

extend Int64

extend Int64

功能：拓展了 Int64 类型作为左操作数和 Duration 类型作为右操作数的乘法运算。

operator func *(Duration)

public operator func *(r: Duration): Duration

功能：实现 Int64 类型和 Duration 类型的乘法，即 Int64 * Duration 运算。

例如 2 * Duration.second 返回表示时间间隔为 2 秒的 Duration 实例。

参数：

• r: Duration - 乘法的右操作数。

返回值：

• Duration - Int64 类型实例和 r 的乘积。

异常：

• ArithmeticException - 当相乘后的结果超出 Duration 的表示范围时，抛出异常。

interface Equal<T>

public interface Equal<T> {
    operator func ==(rhs: T): Bool
}

功能：该接口用于支持判等操作。

operator func ==(T)

operator func ==(rhs: T): Bool

功能：判断两个实例是否相等。

参数：

• rhs: T - 待比较的另一个实例。

返回值：

• Bool - 如果相等，返回 true，否则返回 false。

interface Equatable<T>

public interface Equatable<T> <: Equal<T> & NotEqual<T> {
    operator func !=(rhs: T): Bool
}

功能：该接口是判等和判不等两个接口的集合体。

该接口中提供运算符 != 重载的默认实现，默认实现根据 == 运算的返回值来确定其返回值。例如：如果 a == b 的返回值为 true，则 a != b 返回 false，否则返回 true。

已为部分仓颉类型实现该接口，包括：Unit、Bool 、Rune、Int64、Int32、Int16、Int8、UIntNative、UInt64、UInt32、UInt16、UInt8、Float64、Float32、Float16、String、Array、Box、ArrayList、HashSet。

父类型：

• Equal<T>
• NotEqual<T>

operator func !=(T)

operator func !=(rhs: T): Bool

功能：判断两个实例是否不相等，该函数是此接口的一个默认实现函数。

参数：

• rhs: T - 待比较的另一个实例。

返回值：

• Bool - 如果不相等，返回 true，否则返回 false。

interface GreaterOrEqual<T>

public interface GreaterOrEqual<T> {
    operator func >=(rhs: T): Bool
}

功能：该接口表示大于等于计算。

operator func >=(T)

operator func >=(rhs: T): Bool

功能：判断当前 T 类型实例是否大于等于参数指向的 T 类型实例。

参数：

• rhs: T - 待与当前实例比较的另一个实例。

返回值：

• Bool - 如果大于等于，返回 true，否则返回 false。

interface Greater<T>

public interface Greater<T> {
    operator func >(rhs: T): Bool
}

功能：该接口表示大于计算。

operator func >(T)

operator func >(rhs: T): Bool

功能：判断当前 T 类型实例是否大于参数指向的 T 类型实例。

参数：

• rhs: T - 待与当前实例比较的另一个实例。

返回值：

• Bool - 如果大于，返回 true，否则返回 false。

interface Hashable

public interface Hashable {
    func hashCode(): Int64
}

功能：该接口用于计算哈希值。

已为部分仓颉类型实现该接口，包括：Bool、Rune、IntNative、Int64、Int32、Int16、Int8、UIntNative、UInt64、UInt32、UInt16、UInt8、Float64、Float32、Float16、String、Box。

func hashCode()

func hashCode(): Int64

功能：获得实例类型的哈希值。

返回值：

• Int64 - 返回实例类型的哈希值。

interface Hasher

public interface Hasher {
    func finish(): Int64
    mut func reset(): Unit
    mut func write(value: Bool): Unit
    mut func write(value: Rune): Unit
    mut func write(value: Int8): Unit
    mut func write(value: Int16): Unit
    mut func write(value: Int32): Unit
    mut func write(value: Int64): Unit
    mut func write(value: UInt8): Unit
    mut func write(value: UInt16): Unit
    mut func write(value: UInt32): Unit
    mut func write(value: UInt64): Unit
    mut func write(value: Float16): Unit
    mut func write(value: Float32): Unit
    mut func write(value: Float64): Unit
    mut func write(value: String): Unit
}

功能：该接口用于处理哈希组合运算。

可以使用一系列 write 函数传入不同数据类型实例，并计算他们的组合哈希值。

func finish()

func finish(): Int64

功能：获取哈希运算的结果。

返回值：

• Int64 - 经过计算后的哈希值。

func reset()

mut func reset(): Unit

功能：重置哈希值到 0。

func write(Bool)

mut func write(value: Bool): Unit

功能：把想要哈希运算的 Bool 值传入，然后进行哈希组合运算。

参数：

• value: Bool - 待运算的值。

func write(Float16)

mut func write(value: Float16): Unit

功能：通过该函数把想要哈希运算的 Float16 值传入，然后进行哈希组合运算。

参数：

• value: Float16 - 待运算的值。

func write(Float32)

mut func write(value: Float32): Unit

功能：通过该函数把想要哈希运算的 Float32 值传入，然后进行哈希组合运算。

参数：

• value: Float32 - 待运算的值。

func write(Float64)

mut func write(value: Float64): Unit

功能：通过该函数把想要哈希运算的 Float64 值传入，然后进行哈希组合运算。

参数：

• value: Float64 - 待运算的值。

func write(Int16)

mut func write(value: Int16): Unit

功能：通过该函数把想要哈希运算的 Int16 值传入，然后进行哈希组合运算。

参数：

• value: Int16 - 待运算的值。

func write(Int32)

mut func write(value: Int32): Unit

功能：通过该函数把想要哈希运算的 Int32 值传入，然后进行哈希组合运算。

参数：

• value: Int32 - 待运算的值。

func write(Int64)

mut func write(value: Int64): Unit

功能：通过该函数把想要哈希运算的 Int64 值传入，然后进行哈希组合运算。

参数：

• value: Int64 - 待运算的值。

func write(Int8)

mut func write(value: Int8): Unit

功能：通过该函数把想要哈希运算的 Int8 值传入，然后进行哈希组合运算。

参数：

• value: Int8 - 待运算的值。

func write(Rune)

mut func write(value: Rune): Unit

功能：通过该函数把想要哈希运算的 Rune 值传入，然后进行哈希组合运算。

参数：

• value: Rune - 待运算的值。

func write(String)

mut func write(value: String): Unit

功能：通过该函数把想要哈希运算的 String 值传入，然后进行哈希组合运算。

参数：

• value: String - 待运算的值。

func write(UInt16)

mut func write(value: UInt16): Unit

功能：通过该函数把想要哈希运算的 UInt16 值传入，然后进行哈希组合运算。

参数：

• value: UInt16 - 待运算的值。

func write(UInt32)

mut func write(value: UInt32): Unit

功能：通过该函数把想要哈希运算的 UInt32 值传入，然后进行哈希组合运算。

参数：

• value: UInt32 - 待运算的值。

func write(UInt64)

mut func write(value: UInt64): Unit

功能：通过该函数把想要哈希运算的 UInt64 值传入，然后进行哈希组合运算。

参数：

• value: UInt64 - 待运算的值。

func write(UInt8)

mut func write(value: UInt8): Unit

功能：通过该函数把想要哈希运算的 UInt8 值传入，然后进行哈希组合运算。

参数：

• value: UInt8 - 待运算的值。

interface Iterable<E>

public interface Iterable<E> {
    func iterator(): Iterator<E>
}

功能：该接口表示可迭代，实现了该接口的类型（通常为容器类型）可以在 for-in 语句中实现迭代，也可以获取其对应的迭代器类型实例，调用 next 函数实现迭代。

本包已经为 Array、ArrayList、HashMap 等基础容器类型实现了该接口，用户可以为其他类型实现该接口，使之支持迭代遍历的功能。

func iterator()

func iterator(): Iterator<E>

功能：获取迭代器。

返回值：

• Iterator<E> - 迭代器。

interface LessOrEqual<T>

public interface LessOrEqual<T> {
    operator func <=(rhs: T): Bool
}

功能：该接口表示小于等于计算。

operator func <=(T)

operator func <=(rhs: T): Bool

功能：判断当前 T 类型实例是否小于等于参数指向的 T 类型实例。

参数：

• rhs: T - 待与当前实例比较的另一个实例。

返回值：

• Bool - 如果小于等于，返回 true，否则返回 false。

interface Less<T>

public interface Less<T> {
    operator func <(rhs: T): Bool
}

功能：该接口表示小于计算。

operator func <(T)

operator func <(rhs: T): Bool

功能：判断当前 T 类型实例是否小于参数指向的 T 类型实例。

参数：

• rhs: T - 待与当前实例比较的另一个实例。

返回值：

• Bool - 如果小于，返回 true，否则返回 false。

interface NotEqual<T>

public interface NotEqual<T> {
    operator func !=(rhs: T): Bool
}

功能：该接口用于支持判不等操作。

operator func !=(T)

operator func !=(rhs: T): Bool

功能：判断两个实例是否不相等。

参数：

• rhs: T - 待比较的另一个实例。

返回值：

• Bool - 如果不相等，返回 true，否则返回 false。

interface Resource

public interface Resource {
    func close(): Unit
    func isClosed(): Bool
}

功能：该接口用于资源管理，通常用于内存、句柄等资源的关闭和释放。

实现了该接口的类型可以在 try-with-resource 语法上下文中实现自动资源释放。

func isClosed()

func isClosed(): Bool

功能：判断资源是否已经关闭。

返回值：

• Bool - 如果已经关闭返回 true，否则返回 false。

func close()

func close(): Unit

功能：关闭资源。

interface ThreadContext

public interface ThreadContext {
    func end(): Unit
    func hasEnded(): Bool
}

功能：仓颉线程上下文接口。

用户创建 thread 时，除了缺省 spawn 表达式入参，也可以通过传入不同 ThreadContext 类型的实例，选择不同的线程上下文，然后一定程度上控制并发行为。

目前不允许用户自行实现 ThreadContext 接口，仓颉语言根据使用场景，提供了 MainThreadContext, 具体定义可在终端框架库中查阅。

注意：

在 cjvm 后端，spawn 传入 ThreadContext 类型的参数时，无任何作用。

func end()

func end(): Unit

功能：结束方法，用于向当前 context 发送结束请求。

func hasEnded()

func hasEnded(): Bool

功能：检查方法，用于检查当前 context 是否已结束。

返回值：

• Bool - 如果结束返回 true，否则返回 false。

interface ToString

public interface ToString {
    func toString(): String
}

功能：该接口用来提供具体类型的字符串表示。

func toString()

func toString(): String

功能：获取实例类型的字符串表示。

返回值：

• String - 返回实例类型的字符串表示。

类

class ArrayIterator<T>

public class ArrayIterator<T> <: Iterator<T> {
    public init(data: Array<T>)
}

功能：数组迭代器，迭代功能详述见 Iterable 和 Iterator 说明。

父类型：

• Iterator<T>

init(Array<T>)

public init(data: Array<T>)

功能：给定一个 Array 数组实例，创建其对应的迭代器，用来迭代遍历该数组实例中全部对象。

参数：

• data: Array<T> - 数组实例。

func next()

public func next(): Option<T>

功能：返回数组迭代器中的下一个值。

返回值：

• Option<T> - 数组迭代器中的下一个成员，用 Option 封装，迭代到末尾时返回 None。

示例：

main() {
    var arr: Array<Int64> = [1, 2, 3, 4]
    var arrIterator: ArrayIterator<Int64> = ArrayIterator(arr)
    var num: Option<Int64>
    while (true) {
        num = arrIterator.next()
        if (num.isNone()) {
            break
        }
        println(num.getOrDefault({=> -1}))
    }
}

输出结果为：

1
2
3
4

class Box<T>

public class Box<T> {
    public var value: T
    public init(v: T)
}

功能：Box 类型提供了为其他类型添加一层 class 封装的能力。

如果 T 类型本身不具备引用能力，如 struct 类型，封装后 Box<T> 类型将可被引用。

var value

public var value: T

功能：获取或修改被包装的值。

类型：T

init(T)

public init(v: T)

功能：给定 T 类型实例，构造对应的 Box<T> 实例。

参数：

• v: T - 任意类型实例。

extend<T> Box<T> <: Comparable<Box<T>> where T <: Comparable<T>

extend<T> Box<T> <: Comparable<Box<T>> where T <: Comparable<T>

功能：为 Box<T> 类扩展 Comparable<Box<T>> 接口，提供比较大小的能力。

Box<T> 实例的大小关系与其封装的 T 实例大小关系相同。

父类型：

• Comparable<Box<T>>

func compare(Box<T>)

public func compare(that: Box<T>): Ordering

功能：判断当前 Box 实例与另一个 Box 实例的大小关系。

参数：

• that: Box<T> - 比较的另外一个 Box 对象。

返回值：

• Ordering - 如果当前 Box 实例大于 that，返回 Ordering.GT，等于返回 Ordering.EQ，小于返回 Ordering.LT。

示例：

struct Data <: Comparable<Data> {
    var a: Int64 = 0
    var b: Int64 = 0

    public init(a: Int64, b: Int64) {
        this.a = a
        this.b = b
    }

    public func compare(d: Data) {
        let tValue: Int64 = this.a + this.b
        let dValue: Int64 = d.a + d.b
        if (tValue > dValue) {
            return Ordering.GT
        } else if (tValue == dValue) {
            return Ordering.EQ
        } else {
            return Ordering.LT
        }
    }
}

main() {
    var data1: Box<Data> = Box<Data>(Data(12, 12))
    var data2: Box<Data> = Box<Data>(Data(7, 12))
    println(data1.compare(data2))
}

输出结果为：

Ordering.GT

operator func !=(Box<T>)

public operator func !=(that: Box<T>): Bool

功能：比较 Box 对象是否不相等。

参数：

• that: Box<T> - 比较的另外一个 Box 对象。

返回值：

• Bool - 当前 Box 对象不等于参数 Box 对象返回 true，否则返回 false。

operator func <(Box<T>)

public operator func <(that: Box<T>): Bool

功能：比较 Box 对象的大小。

参数：

• that: Box<T> - 比较的另外一个 Box 对象。

返回值：

• Bool - 当前 Box 对象小于参数 Box 对象返回 true，否则返回 false。

operator func <=(Box<T>)

public operator func <=(that: Box<T>): Bool

功能：比较 Box 对象的大小。

参数：

• that: Box<T> - 比较的另外一个 Box 对象。

返回值：

• Bool - 当前 Box 对象小于等于参数 Box 对象返回 true，否则返回 false。

operator func ==(Box<T>)

public operator func ==(that: Box<T>): Bool

功能：比较 Box 对象是否相等。

参数：

• that: Box<T> - 比较的另外一个 Box 对象。

返回值：

• Bool - 当前 Box 对象等于参数 Box 对象返回 true，否则返回 false。

operator func >(Box<T>)

public operator func >(that: Box<T>): Bool

功能：比较 Box 对象的大小。

参数：

• that: Box<T> - 比较的另外一个 Box 对象。

返回值：

• Bool - 当前 Box 对象大于参数 Box 对象返回 true，否则返回 false。

operator func >=(Box<T>)

public operator func >=(that: Box<T>): Bool

功能：比较 Box 对象的大小。

参数：

• that: Box<T> - 比较的另外一个 Box 对象。

返回值：

• Bool - 当前 Box 对象大于等于参数 Box 对象返回 true，否则返回 false。

extend<T> Box<T> <: Hashable where T <: Hashable

extend<T> Box<T> <: Hashable where T <: Hashable

功能：为 Box<T> 类扩展 Hashable 接口，提供比较大小的能力。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取 Box 对象的哈希值。

实际上该值为 Box 中封装的 T 类型实例的哈希值。

返回值：

• Int64 - 当前 Box 对象的哈希值。

extend<T> Box<T> <: ToString where T <: ToString

extend<T> Box<T> <: ToString where T <: ToString

功能：为 Box<T> 类型扩展 ToString 接口，支持转字符串操作。

父类型：

• ToString

func toString()

public func toString(): String

功能：获取 Box 对象的字符串表示，字符串内容为当前实例封装的 T 类型实例的字符串表示。

返回值：

• String - 转换后的字符串。

class Future<T>

public class Future<T>

功能：Future<T> 实例代表一个仓颉线程任务，可用于获取仓颉线程的计算结果，向仓颉线程发送取消信号。

spawn 表达式的返回类型是 Future<T>，其中 T 的类型取决于 spawn 表达式中的闭包的返回值类型。

prop thread

public prop thread: Thread

功能：获得对应仓颉线程的 Thread 实例。

类型：Thread

func cancel()

public func cancel(): Unit

功能：给当前 Future 实例对应的仓颉线程发送取消请求。该方法不会立即停止线程执行，仅发送请求，相应地，Thread 类的函数 hasPendingCancellation 可用于检查线程是否存在取消请求，用户可以通过该检查来自行决定是否提前终止线程以及如何终止线程。

示例：

main(): Unit {
    let future = spawn { // Create a new thread
        while (true) {
            if (Thread.currentThread.hasPendingCancellation) {
                return 0
            }
        }
        return 1
    }
    //...
    future.cancel() // Send a termination request
    let res = future.get() // Wait for thread termination
    println(res) // 0
}

输出结果为：

0

func get()

public func get(): T

功能：阻塞当前线程，等待并获取当前 Future<T> 对象对应的线程的结果。

返回值：

• T - 当前 Future<T> 实例代表的线程运行结束后的返回值。

示例：

main(): Int64 {
    let fut: Future<Int64> = spawn {
        =>
        sleep(1000 * Duration.millisecond) /* 睡眠 1 秒 */
        return 1
    }

    let result: Int64 = fut.get() /* 等待线程完成 */
    println(result)
    return 0
}

输出结果为：

1

func get(Duration)

public func get(timeout: Duration): T

功能：阻塞当前线程，等待指定时长并获取当前 Future<T> 对象对应的线程的返回值。

需指定等待的超时时间，如果相应的线程在指定时间内未完成执行，则该函数将抛出异常TimeoutException。如果 timeout <= Duration.Zero，等同于 get()，即不限制等待时长。如果线程抛出异常退出执行，在 get 调用处将继续抛出该异常。

参数：

• timeout: Duration - 等待时间。

返回值：

• T - 返回指定时长后仓颉线程执行结果。

异常：

• TimeoutException - 如果相应的线程在指定时间内未完成执行，则该函数将抛出此异常。

示例：

main(): Int64 {
    let fut: Future<Int64> = spawn {
        =>
        sleep(1000 * Duration.millisecond) /* 睡眠 1 秒 */
        return 1
    }

    let result: Int64 = fut.get(2000 * Duration.millisecond)
    /* 最大等待时间为 2 秒， 超过该时间抛出 TimeoutException*/

    println(result)
    return 0
}

输出结果为：

1

func tryGet()

public func tryGet(): Option<T>

功能：尝试获取执行结果，不会阻塞当前线程。如果相应的线程未完成，则该函数返回 None。

返回值：

• Option<T> - 如果当前仓颉线程未完成返回 None，否则返回执行结果。

示例：

main(): Int64 {
    let fut: Future<Int64> = spawn {
        =>
        sleep(1000 * Duration.millisecond) /* 睡眠 1 秒 */
        return 1
    }
    
    /* 主线程等待 4 秒，保证创建线程已经完成 */
    sleep(4000 * Duration.millisecond)

    /* 尝试获取创建线程的运行结果 */
    let result: Option<Int64> = fut.tryGet()
    println(result)
    return 0
}

输出结果为：

Some(1)

class Iterator<T>

public abstract class Iterator<T> <: Iterable<T>

功能：该类表示迭代器，提供 next 方法支持对容器内的成员进行迭代遍历。

父类型：

• Iterable<T>

func iterator()

public func iterator() : Iterator<T>

功能：返回迭代器自身。

返回值：

• Iterator<T> - 迭代器自身。

func next()

public func next(): Option<T>

功能：获取迭代过程中的下一个元素。

返回值：

• Option<T> - 迭代过程中的下一个元素。

示例：

main(): Int64 {
    var arr: Array<Int64> = [1, 2, 3, 4, 5]
    var iter = arr.iterator() /* 获取容器的迭代器对象 */

    while (true) { /* 使用迭代器进行遍历 */
        match (iter.next()) {
            case Some(i) => println(i)
            case None => break
        }
    }
    return 0
}

输出结果为：

1
2
3
4
5

extend<T> Iterator<T>

extend<T> Iterator<T>

功能：扩展 Iterator<T> 类型。

迭代器的方法主要包含中间操作和终止操作。中间操作（如 skip()、map()）会产生一个新的迭代器。而终止操作（如 count()、all()）会根据迭代器产生的元素计算结果，而不产生新的迭代器。每种迭代器方法都会消耗迭代器中不同数量的元素，详见各方法描述。

func all((T) -> Bool)

public func all(predicate: (T)-> Bool): Bool

功能：判断迭代器所有元素是否都满足条件。此方法会重复获取并消耗迭代器中元素直到某个元素不满足条件。

参数：

• predicate: (T) -> Bool - 给定的条件。

返回值：

• Bool - 元素是否都满足条件。

示例：

main(): Int64 {
    var arr: Array<Int64> = [1, 2, 3, 4, 5]
    var iter = arr.iterator() /* 获取容器的迭代器对象 */

    while (true) { /* 使用迭代器进行遍历 */
        match (iter.next()) {
            case Some(i) => println(i)
            case None => break
        }
    }
    return 0
}

输出结果为：

1
2
3
4
5

func any((T) -> Bool)

public func any(predicate: (T)-> Bool): Bool

功能：判断迭代器是否存在任意一个满足条件的元素。此方法会重复获取并消耗迭代器中元素直到某个元素满足条件。

参数：

• predicate: (T) -> Bool - 给定的条件。

返回值：

• Bool - 是否存在任意满足条件的元素。

示例：

main(): Int64 {
    var arr: Array<Int64> = [1, 2, 3, 4, 5]
    var iter = arr.iterator() /* 获取容器的迭代器对象 */

    var flag: Bool = iter.all({v: Int64 => v > 0})
    println(flag)
    return 0
}

输出结果为：

true

func at(Int64)

public func at(n: Int64): Option<T>

功能：获取当前迭代器第 n 个元素，n 从 0 开始计数。此方法会消耗指定元素前的所有元素（包括指定元素）。

参数：

• n: Int64 - 给定的元素序号，序号从 0 开始。

返回值：

• Option<T> - 返回对应位置元素，若 n 大于剩余元素数量则返回 None。

示例：

main(): Int64 {
    var arr: Array<Int64> = [1, 2, 3, 4, 5]
    var iter = arr.iterator() /* 获取容器的迭代器对象 */

    var num: Option<Int64> = iter.at(2)
    println(num)
    return 0
}

输出结果为：

Some(3)

func concat(Iterator<T>)

public func concat(other: Iterator<T>): Iterator<T>

功能：串联两个迭代器，当前迭代器在先，参数表示的迭代器在后。

参数：

• other: Iterator<T> - 要串联在后面的迭代器。

返回值：

• Iterator<T> - 返回串联后的新迭代器。

示例：

main(): Int64 {
    var arr1: Array<Int64> = [1, 2]
    var arr2: Array<Int64> = [3, 4]

    /* 获取容器的迭代器对象 */
    var iter1 = arr1.iterator()
    var iter2 = arr2.iterator()

    /* 合并两个迭代器 */
    var iter = iter1.concat(iter2)

    /* 使用迭代器进行遍历 */
    while (true) {
        match (iter.next()) {
            case Some(i) => println(i)
            case None => break
        }
    }
    return 0
}

输出结果为：

1
2
3
4

func count()

public func count(): Int64

功能：统计当前迭代器包含元素数量。此方法会消耗迭代器中所有元素来计算迭代器中的元素数量。

注意：

该方法会消耗迭代器，即使用该方法后迭代器内不再包含任何元素。

返回值：

• Int64 - 返回迭代器包含元素数量。

示例：

main(): Int64 {
    var arr: Array<Int64> = [1, 2]

    /* 获取容器的迭代器对象 */
    var iter = arr.iterator()
    let len: Int64 = iter.count()
    println(len)

    /* 使用迭代器进行遍历，但是count消耗了迭代器中的元素，因此不会打印 */
    while (true) {
        match (iter.next()) {
            case Some(i) => println(i)
            case None => break
        }
    }
    return 0
}

输出结果为：

2

func enumerate()

public func enumerate(): Iterator<(Int64, T)>

功能：用于获取带索引的迭代器。

返回值：

• Iterator <(Int64, T) > - 返回一个带索引的迭代器。

示例：

main(): Int64 {
    var arr: Array<Int64> = [1, 2]

    /* 获取容器的迭代器对象 */
    var iter = arr.iterator()
    var iter1 = iter.enumerate()

    /* 使用迭代器进行遍历*/
    while (true) {
        match (iter1.next()) {
            case Some(i) =>
                print(i[0].toString() + ' ')
                print(i[1])
                println()
            case None => break
        }
    }
    return 0
}

输出结果为：

0 1
1 2

func filter((T) -> Bool)

public func filter(predicate: (T)-> Bool): Iterator<T>

功能：筛选出满足条件的元素。

参数：

• predicate: (T) -> Bool - 给定的条件，条件为 true 的元素会按顺序出现在返回的迭代器里。

返回值：

• Iterator<T> - 返回一个新迭代器。

示例：

main(): Int64 {
    var arr: Array<Int64> = [1, 2, 3, 4, 5]

    /* 获取过滤后的迭代器对象 */
    var iter = arr.iterator()
    var iter1 = iter.filter({value: Int64 => value > 2})

    /* 使用迭代器进行遍历*/
    while (true) {
        match (iter1.next()) {
            case Some(i) => println(i)
            case None => break
        }
    }
    return 0
}

输出结果为：

3
4
5

func filterMap<R>((T) -> Option<R>)

public func filterMap<R>(transform: (T) -> Option<R>): Iterator<R>

功能：同时进行筛选操作和映射操作，返回一个新的迭代器。

参数：

• transform: (T) -> Option<T> - 给定的映射函数。函数返回值为 Some 对应 filter 的 predicate 为 true，反之表示 false。

返回值：

• Iterator<R> - 返回一个新迭代器。

示例：

main(): Int64 {
    var arr: Array<Int64> = [1, 2, 3, 4, 5]

    /* 获取过滤后的迭代器对象，对元素进行过滤和映射,映射需返回Option类型 */
    var iter = arr.iterator()
    var iter1 = iter.filterMap({
        value: Int64 => if (value > 2) {
            return Some(value + 1)
        } else {
            return None<Int64>
        }
    })

    /* 使用迭代器进行遍历 */
    while (true) {
        match (iter1.next()) {
            case Some(i) => println(i)
            case None => break
        }
    }
    return 0
}

输出结果为：

4
5
6

func first()

public func first(): Option<T>

功能：获取当前迭代器的头部元素。此方法会获取并消耗第一个元素。

返回值：

• Option<T> - 返回头部元素，若为空则返回 None。

示例：

main(): Int64 {
    var arr: Array<Int64> = [1, 2, 3, 4, 5]

    /* 获取迭代器对象 */
    var iter = arr.iterator()
    var head: Option<Int64> = iter.first()
    println(head)

    return 0
}

输出结果为：

Some(1)

func flatMap<R>((T) -> Iterator<R>)

public func flatMap<R>(transform: (T) -> Iterator<R>): Iterator<R>

功能：创建一个带 flatten 功能的映射。

参数：

• transform: (T) -> Iterable<R> - 给定的映射函数。

返回值：

• Iterator<R> - 返回一个带 flatten 功能的映射。

示例：

main(): Int64 {
    var arr: Array<Array<Int64>> = [[1], [2], [3], [4, 5]]

    /* 获取带flatten功能的迭代器对象 */
    var iter = arr.iterator()
    var iter1 = iter.flatMap({value => value.iterator()})

    /* 使用迭代器进行展开遍历*/
    while (true) {
        match (iter1.next()) {
            case Some(i) => println(i)
            case None => break
        }
    }
    return 0
}

输出结果为：

1
2
3
4
5

func fold<R>(R, (R, T) -> R)

public func fold<R>(initial: R, operation: (R, T)->R): R

功能：使用指定初始值，从左向右计算。此方法会消耗迭代器中的所有元素。

参数：

• initial: R - 给定的 R 类型的初始值。
• operation: (R, T) -> R - 给定的计算函数。

返回值：

• R - 返回最终计算得到的值。

func forEach((T) -> Unit)

public func forEach(action: (T)-> Unit): Unit

功能：遍历当前迭代器所有元素，对每个元素执行给定的操作。此方法会消耗迭代器中的所有元素。

参数：

• action: (T) -> Unit - 给定的操作函数。

func inspect((T) -> Unit)

public func inspect(action: (T) -> Unit): Iterator<T>

功能：迭代器每次调用 next() 对当前元素执行额外操作（不会消耗迭代器中元素）。

参数：

• action: (T) -> Unit - 给定的操作函数。

返回值：

• Iterator<T> - 返回一个新迭代器。

func intersperse(T)

public func intersperse(separator: T): Iterator<T>

功能：迭代器每两个元素之间插入一个给定的新元素。

参数：

• separator: T - 给定的元素。

返回值：

• Iterator<T> - 返回一个新迭代器。

func isEmpty()

public func isEmpty(): Bool

功能：判断当前迭代器是否为空。此方法会调用 next() ，根据其返回值判断当前迭代器是否为空。因此如果当前迭代器不为空，则会消耗一个元素。

返回值：

• Bool - 返回当前迭代器是否为空。

func last()

public func last(): Option<T>

功能：获取当前迭代器尾部元素。此方法会获取并消耗迭代器中的所有元素，并返回最后一个元素。

返回值：

• Option<T> - 返回尾部元素，若为空则返回 None。

func map<R>((T) -> R)

public func map<R>(transform: (T)-> R): Iterator<R>

功能：创建一个映射。

参数：

• transform: (T) ->R - 给定的映射函数。

返回值：

• Iterator<R> - 返回一个映射。

func none((T) -> Bool)

public func none(predicate: (T)-> Bool): Bool

功能：判断当前迭代器中所有元素是否都不满足条件。此方法会重复获取并消耗迭代器中元素直到某个元素满足条件。

参数：

• predicate: (T) -> Bool - 给定的条件。

返回值：

• Bool - 当前迭代器中元素是否都不满足条件。

func reduce((T, T) -> T)

public func reduce(operation: (T, T) -> T): Option<T>

功能：使用第一个元素作为初始值，从左向右计算。此方法会消耗迭代器中的所有元素。

参数：

• operation: (T, T) -> T - 给定的计算函数。

返回值：

• Option<T> - 返回计算结果。

func skip(Int64)

public func skip(count: Int64): Iterator<T>

功能：从前往后从当前迭代器跳过特定个数。

当 count 小于 0 时，抛出异常。当 count 等于 0 时，相当没有跳过任何元素，返回原迭代器。当 count 大于0并且count小于迭代器的大小时，跳过 count 个元素后，返回含有剩下的元素的新迭代器。当 count 大于等于迭代器的大小时，跳过所有元素，返回空迭代器。

参数：

• count: Int64 - 要跳过的个数。

返回值：

• Iterator<T> - 返回一个跳过指定数量元素的迭代器。

异常：

• IllegalArgumentException - 当 count < 0 时，抛出异常。

func step(Int64)

public func step(count: Int64): Iterator<T>

功能：迭代器每次调用 next() 跳过特定个数。

当 count 小于等于 0 时，抛出异常。当 count 大于 0 时，每次调用 next() 跳过 count 次，直到迭代器为空。

参数：

• count: Int64 - 每次调用 next() 要跳过的个数。

返回值：

• Iterator<T> - 返回一个新迭代器，这个迭代器每次调用 next() 会跳过特定个数。

异常：

• IllegalArgumentException - 当 count <= 0 时，抛出异常。

func take(Int64)

public func take(count: Int64): Iterator<T>

功能：从当前迭代器取出特定个数。

从后往前取出当前迭代器特定个数的元素。当 count 小于 0 时，抛出异常。当 count 等于 0 时，不取元素，返回空迭代器。当 count 大于 0 小于迭代器的大小时，取前 count 个元素，返回新迭代器。当 count 大于等于迭代器的大小时，取所有元素，返回原迭代器。

参数：

• count: Int64 - 要取出的个数。

返回值：

• Iterator<T> - 返回一个取出指定数量元素的迭代器。

异常：

• IllegalArgumentException - 当 count < 0 时，抛出异常。

func zip<R>(Iterator<R>)

public func zip<R>(it: Iterator<R>): Iterator<(T, R)>

功能：将两个迭代器合并成一个（长度取决于短的那个迭代器）。

参数：

• it: Iterator<R> - 要合并的其中一个迭代器。

返回值：

• Iterator<(T, R)> - 返回一个新迭代器。

extend<T> Iterator<T> where T <: Comparable<T>

extend<T> Iterator<T> where T <: Comparable<T>

功能：为 Iterator<T> 类型扩展 Comparable<T> 接口，支持比较操作。

func max()

public func max(): Option<T>

功能：筛选最大的元素。此方法会消耗迭代器中的所有元素。

返回值：

• Option<T> - 返回最大的元素，若为空则返回 None。

func min()

public func min(): Option<T>

功能：筛选最小的元素。此方法会消耗迭代器中的所有元素。

返回值：

• Option<T> - 返回最小的元素，若为空则返回 None。

extend<T> Iterator<T> where T <: Equatable<T>

extend<T> Iterator<T> where T <: Equatable<T>

功能：为 Iterator<T> 类型扩展 扩展 Equatable<T> 接口，支持判等操作。

func contains(T)

public func contains(element: T): Bool

功能：遍历所有元素，判断是否包含指定元素。此方法会重复获取并消耗迭代器中元素直到某个元素与参数 element 相等。

参数：

• element: T - 要查找的元素。

返回值：

• Bool - 是否包含指定元素。

class Object

public open class Object <: Any {
    public const init()
}

功能：Object 是所有 class 的父类，所有 class 都默认继承它。Object 类中不包含任何成员，即 Object 是一个“空”的类。

父类型：

• Any

init()

public const init()

功能：构造一个 object 实例。

class RangeIterator<T> <: Iterator<T> where T <: Countable<T> & Comparable<T> & Equatable<T>

public class RangeIterator<T> <: Iterator<T> where T <: Countable<T> & Comparable<T> & Equatable<T>

功能：Range 类型的迭代器，迭代功能详述见 Iterable 和 Iterator 接口说明。

父类型：

• Iterator<T>

func next()

public func next(): Option<T>

功能：获取 Range 迭代器中的下一个值。

返回值：

• Option<T> - Range 迭代器中的下一个成员，用 Option 封装，迭代到末尾时返回 None。

class StackTraceElement

public open class StackTraceElement {
    public let declaringClass: String
    public let methodName: String
    public let fileName: String
    public let lineNumber: Int64
    public init(declaringClass: String, methodName: String, fileName: String, lineNumber: Int64)
}

功能：表示一个异常堆栈的具体信息，包括异常发生的类名、函数名、文件名、行号。

let declaringClass

public let declaringClass: String

功能：获取异常发生的类名。

类型：String

let fileName

public let fileName: String

功能：获取异常发生的文件名。

类型：String

let lineNumber

public let lineNumber: Int64

功能：获取异常发生的行号。

类型：Int64

let methodName

public let methodName: String

功能：获取异常发生的函数名。

类型：String

init(String, String, String, Int64)

public init(declaringClass: String, methodName: String, fileName: String, lineNumber: Int64)

功能：构造一个异常堆栈实例，指定类名、函数名、文件名、行号。

参数：

• declaringClass: String - 类名。
• methodName: String - 函数名。
• fileName: String - 文件名。
• lineNumber: Int64 - 行号。

class StringBuilder

public class StringBuilder <: ToString {
    public init()
    public init(str: String)
    public init(r: Rune, n: Int64)
    public init(value: Array<Rune>)
    public init(capacity: Int64)
}

功能：该类主要用于字符串的构建。

StringBuilder 在字符串的构建上效率高于 String：

• 在功能上支持传入多个类型的值，该类将自动将其转换为 String 类型对象，并追加到构造的字符串中。
• 在性能上使用动态扩容算法，减少内存申请频率，构造字符串的速度更快，占用内存资源通常更少。

注意：

StringBuilder 仅支持 UTF-8 编码的字符数据。

父类型：

• ToString

prop capacity

public prop capacity: Int64

功能：获取 StringBuilder 实例此时能容纳字符串的长度，该值会随扩容的发生而变大。

类型：Int64

prop size

public prop size: Int64

功能：获取 StringBuilder 实例中字符串长度。

类型：Int64

init()

public init()

功能：构造一个初始容量为 32 的空 StringBuilder 实例。

init(Array<Rune>)

public init(value: Array<Rune>)

功能：使用参数 value 指定的字符数组初始化一个 StringBuilder 实例，该实例的初始容量为 value 大小，初始内容为 value 包含的字符内容。

参数：

• value: Array<Rune> - 初始化 StringBuilder 实例的字符数组。

init(Int64)

public init(capacity: Int64)

功能：使用参数 capacity 指定的容量初始化一个空 StringBuilder 实例，该实例的初始容量为 value 大小，初始内容为若干 \0 字符。

参数：

• capacity: Int64 - 初始化 StringBuilder 的字节容量，取值范围为 (0, Int64.Max]。

异常：

• IllegalArgumentException - 当参数 capacity 的值小于等于 0 时，抛出异常。

init(Rune, Int64)

public init(r: Rune, n: Int64)

功能：使用 n 个 r 字符初始化 StringBuilder 实例，该实例的初始容量为 n，初始内容为 n 个 r 字符。

参数：

• r: Rune - 初始化 StringBuilder 实例的字符。
• n: Int64 - 字符 r 的数量，取值范围为 [0, Int64.Max]。

异常：

• IllegalArgumentException - 当参数 n 小于 0 时，抛出异常。

init(String)

public init(str: String)

功能：根据指定初始字符串构造 StringBuilder 实例，该实例的初始容量为指定字符串的大小，初始内容为指定字符串。

参数：

• str: String - 初始化 StringBuilder 实例的字符串。

func append(Array<Rune>)

public func append(runeArr: Array<Rune>): Unit

功能：在 StringBuilder 末尾插入一个 Rune 数组中所有字符。

参数：

• runeArr: Array<Rune> - 插入的 Rune 数组。

func append<T>(Array<T>) where T <: ToString

public func append<T>(val: Array<T>): Unit where T <: ToString

功能：在 StringBuilder 末尾插入参数 val 指定的 Array<T> 的字符串表示，类型 T 需要实现 ToString 接口。

参数：

• val: Array<T> - 插入的 Array<T> 类型实例。

func append(Bool)

public func append(b: Bool): Unit

功能：在 StringBuilder 末尾插入参数 b 的字符串表示。

参数：

• b: Bool - 插入的 Bool 类型的值。

func append(CString)

public func append(cstr: CString): Unit

功能：在 StringBuilder 末尾插入参数 cstr 指定 CString 中的内容。

参数：

• cstr: CString - 插入的 CString。

func append(Float16)

public func append(n: Float16): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: Float16 - 插入的 Float16 类型的值。

func append(Float32)

public func append(n: Float32): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: Float32 - 插入的 Float32 类型的值。

func append(Float64)

public func append(n: Float64): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: Float64 - 插入的 Float64 类型的值。

func append(Int16)

public func append(n: Int16): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: Int16 - 插入的 Int16 类型的值。

func append(Int32)

public func append(n: Int32): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: Int32 - 插入的 Int32 类型的值。

func append(Int64)

public func append(n: Int64): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: Int64 - 插入的 Int64 类型的值。

func append(Int8)

public func append(n: Int8): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: Int8 - 插入的 Int8 类型的值。

func append(Rune)

public func append(r: Rune): Unit

功能：在 StringBuilder 末尾插入参数 r 指定的字符。

参数：

• r: Rune - 插入的字符。

func append(String)

public func append(str: String): Unit

功能：在 StringBuilder 末尾插入参数 str 指定的字符串。

参数：

• str: String - 插入的字符串。

func append(StringBuilder)

public func append(sb: StringBuilder): Unit

功能：在 StringBuilder 末尾插入参数 sb 指定的 StringBuilder 中的内容。

参数：

• sb: StringBuilder - 插入的 StringBuilder 实例。

func append<T>(T) where T <: ToString

public func append<T>(v: T): Unit where T <: ToString

功能：在 StringBuilder 末尾插入参数 v 指定 T 类型的字符串表示，类型 T 需要实现 ToString 接口。

参数：

• v: T - 插入的 T 类型实例。

func append(UInt16)

public func append(n: UInt16): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: UInt16 - 插入的 UInt16 类型的值。

func append(UInt32)

public func append(n: UInt32): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: UInt32 - 插入的 UInt32 类型的值。

func append(UInt64)

public func append(n: UInt64): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: UInt64 - 插入的 UInt64 类型的值。

func append(UInt8)

public func append(n: UInt8): Unit

功能：在 StringBuilder 末尾插入参数 n 的字符串表示。

参数：

• n: UInt8 - 插入的 UInt8 类型的值。

func appendFromUtf8(Array<Byte>)

public func appendFromUtf8(arr: Array<Byte>): Unit

功能：在 StringBuilder 末尾插入参数 arr 指向的字节数组。

该函数要求参数 arr 符合 UTF-8 编码，如果不符合，将抛出异常。

参数：

• arr: Array<Byte> - 插入的字节数组。

异常：

• IllegalArgumentException - 当字节数组不符合 utf8 编码规则时，抛出异常。

func appendFromUtf8Unchecked(Array<Byte>)

public unsafe func appendFromUtf8Unchecked(arr: Array<Byte>): Unit

功能：在 StringBuilder 末尾插入参数 arr 指向的字节数组。

相较于 appendFromUtf8 函数，它并没有针对于字节数组进行 UTF-8 相关规则的检查，所以它所构建的字符串并不一定保证是合法的，甚至出现非预期的异常，如果不是某些场景下的速度考虑，请优先使用安全的 appendFromUtf8 函数。

参数：

• arr: Array<Byte> - 插入的字节数组。

func reserve(Int64)

public func reserve(additional: Int64): Unit

功能：将 StringBuilder 扩容 additional 大小。

当 additional 小于等于零，或剩余容量大于等于 additional 时，不发生扩容；当剩余容量小于 additional 时，扩容至当前容量的 1.5 倍（向下取整）与 size + additional 的最大值。

参数：

• additional: Int64 - 指定 StringBuilder 的扩容大小。

func reset(Option<Int64>)

public func reset(capacity!: Option<Int64> = None): Unit

功能：清空当前 StringBuilder，并将容量重置为 capacity 指定的值。

参数：

• capacity!: Option<Int64> - 重置后 StringBuilder 实例的容量大小，取值范围为 None 和 (Some(0), Some(Int64.Max)]，默认值 None 表示采用默认大小容量（32）。

异常：

• IllegalArgumentException - 当参数 capacity 的值小于等于 0 时，抛出异常。

func toString()

public func toString(): String

功能：获取 StringBuilder 实例中的字符串。

注意：

该函数不会将字符串数据进行拷贝。

返回值：

• String - StringBuilder 实例中的字符串。

class Thread

public class Thread

功能：Thread 类代表一个仓颉类，可用于获取线程 ID 及名字、查询线程是否存在取消请求、注册线程未处理异常的处理函数等。

该类型实例无法通过构造得到，仅能通过 Future 对象的 thread 属性或是 Thread 类的 currentThread 静态属性获取。

static prop currentThread

public static prop currentThread: Thread

功能：获取当前执行线程的 Thread 对象。

类型：Thread

prop hasPendingCancellation

public prop hasPendingCancellation: Bool

功能：线程是否存在取消请求，即是否通过 future.cancel() 发送过取消请求，常见使用方为 Thread.currentThread.hasPendingCancellation。

类型：Bool

prop id

public prop id: Int64

功能：获取当前执行线程的标识，以 Int64 表示，所有存活的线程都有不同标识，但不保证当线程执行结束后复用它的标识。

类型：Int64

prop name

public mut prop name: String

功能：获取或设置线程的名称，获取设置都具有原子性。

类型：String

static func handleUncaughtExceptionBy((Thread, Exception) -> Unit)

public static func handleUncaughtExceptionBy(exHandler: (Thread, Exception) -> Unit): Unit

功能：注册线程未处理异常的处理函数。

当某一线程因异常而提前终止后，如果全局的未处理异常函数被注册，那么将调用该函数并结束线程，在该函数内抛出异常时，将向终端打印提示信息并结束线程，但不会打印异常调用栈信息；如果没有注册全局异常处理函数，那么默认会向终端打印异常调用栈信息。

多次注册处理函数时，后续的注册函数将覆盖之前的处理函数。

当有多个线程同时因异常而终止时，处理函数将被并发执行，因而开发者需要在处理函数中确保并发正确性。

处理函数的参数第一个参数类型为 Thread，是发生异常的线程，第二个参数类型为 Exception，是线程未处理的异常。

参数：

• exHandler: (Thread, Exception) -> Unit - 注册的处理函数。

class ThreadLocal<T>

public class ThreadLocal<T>

功能：该类表示仓颉线程局部变量。

和普通变量相比，线程局部变量有不同的访问语义。当多个线程共享使用同一线程局部变量时，每个线程都有各自的一份值拷贝。线程对变量的访问会读写线程本地的值，而不会影响其他线程中变量的值。

func get()

public func get(): ?T

功能：获得仓颉线程局部变量的值。

返回值：

• ?T - 如果当前线程局部变量不为空值，返回该值，如果为空值，返回 None。

func set(?T)

public func set(value: ?T): Unit

功能：通过 value 设置仓颉线程局部变量的值，如果传入 None，该局部变量的值将被删除，在线程后续操作中将无法获取。

参数：

• value: ?T - 需要设置的局部变量的值。

枚举

enum AnnotationKind

public enum AnnotationKind {
    | Type
    | Parameter
    | Init
    | MemberProperty
    | MemberFunction
    | MemberVariable
    | EnumConstructor
    | GlobalFunction
    | GlobalVariable
    | Extension
    | TypeAlias
    | ...
}

功能：表示自定义注解希望支持的位置。

EnumConstructor

EnumConstructor

功能：枚举构造器声明。

Extension

Extension

功能：扩展声明。

Init

Init

功能：构造函数声明。

GlobalFunction

GlobalFunction

功能：全局函数声明。

GlobalVariable

GlobalVariable

功能：全局变量声明。

MemberFunction

MemberFunction

功能：成员函数声明。

MemberProperty

MemberProperty

功能：成员属性声明。

MemberVariable

MemberVariable

功能：成员变量声明。

Parameter

Parameter

功能：成员函数/构造函数中的参数（不包括枚举构造器的参数）。

Type

Type

功能：类型声明（class、struct、enum、interface）。

TypeAlias

TypeAlias

功能：类型别名声明。

enum Endian

public enum Endian {
    | Big
    | Little
}

功能：枚举类型 Endian 表示运行平台的端序，分为大端序和小端序。

Big

Big

功能：表示大端序。

Little

Little

功能：表示小端序。

static prop Platform

public static prop Platform: Endian

功能：获取所在运行平台的端序。

类型：Endian

异常：

• UnsupportedException - 当所运行平台返回的端序无法识别时，抛出异常。

示例：

main() {
    let e = Endian.Platform
    match (e) {
        case Big => println("BigEndian")
        case Little => println("LittleEndian")
    }
}

enum Option<T>

public enum Option<T> {
    | Some(T)
    | None
}

功能：Option<T> 是对 T 类型的封装，表示可能有值也可能无值。

它包含两个构造器：Some 和 None。其中，Some 会携带一个参数，表示有值，None 不带参数，表示无值。当需要表示某个类型可能有值，也可能没有值的时候，可选择使用 Option 类型。

Option 类型的另一种写法是在类型名前加 ?，即对于任意类型 Type，?Type 等价于 Option<Type>。

None

None

功能：构造一个不带参数的 Option<T> 实例，表示无值。

Some(T)

Some(T)

功能：构造一个携带参数的 Option<T> 实例，表示有值。

func filter((T)->Bool)

public func filter(predicate: (T) -> Bool): Option<T>

功能：提供 Option 类型的 '过滤' 功能。

参数：

• predicate: (T) -> Bool - 过滤函数。

返回值：

• Option<T> - 如果 Option 值是 Some(v)，并且 v 满足 predicate(v) = true 时，返回 Some(v)， 否则返回 None。

func flatMap<R>((T) -> Option<R>)

public func flatMap<R>(transform: (T) -> Option<R>): Option<R>

功能：提供从 Option<T> 类型到 Option<R> 类型的映射函数，如果当前实例值是 Some，执行 transform 函数，并且返回结果，否则返回 None。

参数：

• transform: (T) -> Option<R> - 映射函数。

返回值：

• Option<R> - 如果当前实例值是 Some，执行 transform 函数并返回，否则返回 None。

func getOrDefault(() -> T)

public func getOrDefault(other: () -> T): T

功能：获得值或返回默认值。如果 Option 值是 Some，则返回类型为 T 的实例，如果 Option 值是 None，则调用入参，返回类型 T 的值。

参数：

• other: () -> T - 默认函数，如果当前实例的值是 None，调用该函数得到类型为 T 的实例，并将其返回。

返回值：

• T - 如果当前实例的值是 Some<T>，则返回当前实例携带的类型为 T 的实例，如果 Option 值是 None，调用入参指定的函数，得到类型为 T 的实例，并将其返回。

func getOrThrow(() -> Exception)

public func getOrThrow(exception: ()->Exception): T

功能：获得值或抛出指定异常。

参数：

• exception: () ->Exception - 异常函数，如果当前实例值是 None，将执行该函数并将其返回值作为异常抛出。

返回值：

• T - 如果当前实例值是 Some<T>，返回类型为 T 的实例。

异常：

• Exception - 如果当前实例是 None，抛出异常函数返回的异常。

func getOrThrow()

public func getOrThrow(): T

功能：获得值或抛出异常。

返回值：

• T - 如果当前实例值是 Some<T>，返回类型为 T 的实例。

异常：

• NoneValueException - 如果当前实例是 None，抛出异常。

func isNone()

public func isNone(): Bool

功能：判断当前实例值是否为 None。

返回值：

• Bool - 如果当前实例值是 None，则返回 true，否则返回 false。

func isSome()

public func isSome(): Bool

功能：判断当前实例值是否为 Some。

返回值：

• Bool - 如果当前实例值是 Some，则返回 true，否则返回 false。

func map<R>((T)->R)

public func map<R>(transform: (T)-> R): Option<R>

功能：提供从 Option<T> 类型到 Option<R> 类型的映射函数，如果当前实例值是 Some，执行 transform 函数，并且返回 Some 封装的结果，否则返回 None。

参数：

• transform: (T)-> R - 映射函数。

返回值：

• Option<R> - 如果当前实例值是 Some，执行 transform 函数，并且返回 Option 类型的结果，否则返回 None。

extend<T> Option<T> <: Equatable<Option<T>> where T <: Equatable<T>

extend<T> Option<T> <: Equatable<Option<T>> where T <: Equatable<T>

功能：为 Option<T> 枚举扩展 Equatable<Option<T>> 接口，支持判等操作。

父类型：

• Equatable<Option<T>>

operator func !=(Option<T>)

public operator func !=(that: Option<T>): Bool

功能：判断当前实例与参数指向的 Option<T> 实例是否不等。

参数：

• that: Option<T> - 待比较的 Option<T> 实例。

返回值：

• Bool - 如果不相等，则返回 true，否则返回 false。

operator func ==(Option<T>)

public operator func ==(that: Option<T>): Bool

功能：判断当前实例与参数指向的 Option<T> 实例是否相等。

如果两者同为 None，则相等；如果两者为 Some(v1) 和 Some(v2)，且 v1 和 v2 相等，则相等。

参数：

• that: Option<T> - 待比较的 Option<T> 实例。

返回值：

• Bool - 如果相等，则返回 true，否则返回 false。

extend<T> Option<T> <: Hashable where T <: Hashable

extend<T> Option<T> <: Hashable where T <: Hashable

功能：为 Option 类型扩展 Hashable 接口。

Some<T> 的哈希值等于 T 的值对应的哈希值，None 的哈希值等于 Int64(0)。

父类型：

• Hashable

func hashCode()

public func hashCode(): Int64

功能：获取哈希值。

返回值：

• Int64 - 哈希值。

extend<T> Option<T> <: ToString where T <: ToString

extend<T> Option<T> <: ToString where T <: ToString

功能：为 Option<T> 枚举实现 ToString 接口，支持转字符串操作。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Option 转换为可输出的字符串，字符串内容为 "Some(${T.toString()})" 或 "None"。

返回值：

• String - 转化后的字符串。

extend<T> Option<Option<T>>

extend<T> Option<Option<T>>

功能：为 Option<Option<T>> 类型扩展实现某些功能。

func flatten()

public func flatten(): Option<T>

功能：将 Option <Option <T>> 类型展开，如果当前实例是 Some(Option <T>.Some(v)), 展开后的结果为 Some(v)。

返回值：

• Option<T> - Option <Option <T>> 类型展开后的结果。

enum Ordering

public enum Ordering {
    | LT
    | GT
    | EQ
}

功能：Ordering 表示比较大小的结果，它包含三种情况：小于，大于和等于。

EQ

EQ

功能：构造一个 Ordering 实例，表示等于。

GT

GT

功能：构造一个 Ordering 实例，表示大于。

LT

LT

功能：构造一个 Ordering 实例，表示小于。

extend Ordering <: Comparable

extend Ordering <: Comparable<Ordering>

功能：为 Ordering 类型其扩展 Comparable<Ordering> 接口，支持比较操作。

父类型：

• Comparable<Ordering>

func compare(Ordering)

public func compare(that: Ordering): Ordering

功能：判断当前 Ordering 实例与参数指定的 Ordering 实例的大小关系。

Ordering 枚举的大小关系为：GT > EQ > LT。

参数：

• that: Ordering - 待比较的 Ordering 实例。

返回值：

• Ordering - 如果大于，返回 GT，如果等于，返回 EQ，如果小于，返回 LT。

extend Ordering <: Hashable

extend Ordering <: Hashable

功能：为 Ordering 类型其扩展 Hashable 接口，支持计算哈希值。

父类型：

• Hashable

func hashCode

public func hashCode(): Int64

功能：获取哈希值，GT 的哈希值是 3，EQ 的哈希值是 2，LT 的哈希值是 1。

返回值：

• Int64 - 哈希值。

extend Ordering <: ToString

extend Ordering <: ToString

功能：为 Ordering 类型其扩展 ToString 接口，支持转字符串操作。

父类型：

• ToString

func toString()

public func toString(): String

功能：将 Ordering 转换为可输出的字符串。

转换结果如下：

• GT："Ordering.GT"。
• LT："Ordering.ET"。
• EQ："Ordering.EQ"。

返回值：

• String - 转化后的字符串。

结构体

struct Array<T>

public struct Array<T> {
    public const init()
    public init(size: Int64, repeat!: T)
    public init(size: Int64, initElement: (Int64) -> T)
}

功能：仓颉数组类型，用来表示单一类型的元素构成的有序序列。

T 表示数组的元素类型，T 可以是任意类型。

prop first

public prop first: Option<T>

功能：获取当前数组的第一个元素，如果当前数组为空，返回 None。

类型：Option<T>

prop last

public prop last: Option<T>

功能：获取当前数组的最后一个元素，如果当前数组为空，返回 None。

类型：Option<T>

init()

public const init()

功能：构造一个空数组。

init(Int64, (Int64) -> T)

public init(size: Int64, initElement: (Int64) -> T)

功能：创建指定长度的数组，其中元素根据初始化函数计算获取。

即：将 [0, size) 范围内的值分别传入初始化函数 initElement，执行得到数组对应下标的元素。

参数：

• size: Int64 - 数组大小。
• initElement: (Int64) ->T - 初始化函数。

异常：

• NegativeArraySizeException - 当 size 小于 0，抛出异常。

init(Int64, T)

public init(size: Int64, repeat!: T)

功能：构造一个指定长度的数组，其中元素都用指定初始值进行初始化。

注意：

该构造函数不会拷贝 repeat， 如果 repeat 是一个引用类型，构造后数组的每一个元素都将指向相同的引用。

参数：

• size: Int64 - 数组大小，取值范围为 [0, Int64.Max]。
• repeat!: T - 数组元素初始值。

异常：

• NegativeArraySizeException - 当 size 小于 0，抛出异常。

func clone()

public func clone(): Array<T>

功能：克隆数组，将对数组数据进行深拷贝。

返回值：

• Array<T> - 克隆得到的新数组。

func clone(Range<Int64>)

public func clone(range: Range<Int64>) : Array<T>

功能：克隆数组的指定区间。

注意：

1. 如果参数 range 是使用 Range 构造函数构造的 Range 实例，有如下行为：
   • start 的值就是构造函数传入的值本身，不受构造时传入的 hasStart 的值的影响。
   • hasEnd 为 false 时，end 值不生效，且不受构造时传入的 isClosed 的值的影响，数组切片取到原数组最后一个元素。
2. range 的步长只能为 1。

参数：