Value Type之间的类型转换#

对于数值类型, 支持如下类型转换**(未列出即表示不支持)**:

1. Rune类型到UInt32类型的转换
2. 整数类型(包括Int8, Int16, Int32, Int64, IntNative, UInt8, UInt16, UInt32, UInt64, UIntNative)到Rune类型的转换
3. 所有数值类型(包括Int8, Int16, Int32, Int64, IntNative, UInt8, UInt16, UInt32, UInt64, UIntNative, Float16, Float32, Float64)之间的双向转换

Rune到UInt32的转换使用UInt32(e)的方式, 其中e是一个Rune类型的表达式, UInt32(e)的结果是e的 Unicode scalar value 对应的UInt32类型的整数值

整数类型到Rune的转换使用Rune(num)的方式, 其中num的类型可以是任意的整数类型, 且仅当num的值落在[0x0000, 0xD7FF]或[0xE000, 0x10FFFF](即 Unicode scalar value)中时, 返回对应的 Unicode scalar value 表示的字符, 否则, 编译报错(编译时可确定num的值)或运行时抛异常

1
main(){
2
    var c: Rune = 'a'
3
    var num: UInt32 = 0
4
    num = UInt32(c)    // num = 97
5
    num -= 32           // num = 65
6
    c = Rune(num)      // c =`A`
7

8
    return 0
9
}

仓颉值类型的强制类型转换, 只支持:

1. 整型和浮点型之间的转换
2. Rune到UInt32的转换
3. 整型到Rune有规则限制的转换

如果把Rune单纯看作C/C++中的char, 那与C中的整型与浮点型之间的强制类型转换还是比较相似的

但Rune可表示字符的范围, 要比C/C++中的char要大多了, 所以整型到Rune的转换才要限制

为了保证类型安全, 仓颉编程语言不支持数值类型之间的隐式类型转换(数值字面量的类型由上下文推断得到, 这种情形并不是隐式类型转换), 要实现一种数值类型到另外一种数值类型的转换, 必须使用显式的方式:NumericType(expr), 表示将expr的类型强制转换为NumericType类型(NumericType表示任意一种数值类型), 如转换成功, 会返回一个新的从expr构造而来的类型为NumericType的值

数值类型转换的语法定义为:

1
numericTypeConvExpr
2
    : numericTypes '(' expression ')'
3
       ;
4

5
numericTypes
6
       : 'Int8' | 'Int16' | 'Int32' | 'Int64' | 'IntNative' | 'UInt8' | 'UInt16' | 'UInt32' | 'UInt64' | 'UIntNative' | 'Float16' | 'Float32' | 'Float64'
7
       ;

如果根据数值类型所占bit数来定义数值类型间的”大小关系”(所占bit数越多, 类型越”大”, 所占bit数越少, 类型越”小”), 则仓颉编程语言支持以下类型转换:

a)有符号整数类型之间的双向转换: 小转大时数值结果不变, 大转小时 若超出小类型的表示范围, 则根据上下文中的属性宏确定溢出处理策略(默认使用抛出异常的策略), 不同溢出策略详见[算术表达式]

下面以Int8和Int16之间的转换为例进行说明(溢出时, 使用抛异常的处理策略):

1
main(){
2
    var i8Number: Int8 = 127
3
    var i16Number: Int16 = 0
4

5
    i16Number = Int16(i8Number)        // ok: i16Number = 127
6
    i8Number = Int8(i16Number)        // ok: i8Number = 127
7
    i16Number = 128
8
    i8Number = Int8(i16Number)        // throw an ArithmeticException
9

10
    return 0
11
}

b)无符号整数类型之间的双向转换: 规则同上

以UInt16和UInt32之间的转换为例进行说明(其他情况遵循一样的规则):

1
main(){
2
    var u16Number: UInt16 = 65535
3
    var u32Number: UInt32 = 0
4

5
    u32Number = UInt32(u16Number)        // ok: u32Number = 65535
6
    u16Number = UInt16(u32Number)        // ok: u16Number = 65535
7
    u32Number = 65536
8
    u16Number = UInt16(u32Number)        // throw an ArithmeticException
9

10
    return 0
11
}

仓颉这一点就与C/C++很不一样!

同符号的整型整型之间的转换, 溢出默认抛异常!!!!

我勒个强类型语言啊, C/C++如果这样就能少很多不容易定位的BUG了

c)浮点类型之间的双向转换: 使用round-to-nearest模式

举例说明Float32和Float64之间的转换:

1
main(){
2
    var f32Number: Float32 = 1.1
3
    var f64Number: Float64 = 0.0
4

5
    f64Number = Float64(f32Number)        // f64Number = 1.100000023841858
6
    f32Number = Float32(f64Number)        // f32Number = 1.1
7

8
    f64Number = 1.123456789
9
    f32Number = Float32(f64Number)        // f32Number = 1.1234568
10

11
    f32Number = 4.4E38                    // f32Number = POSITIVE_INFINITY
12
    f64Number = Float64(f32Number)        // f64Number = POSITIVE_INFINITY
13

14
    f64Number = 4.4E38
15
    f32Number = Float32(f64Number)        // f32Number = POSITIVE_INFINITY
16

17
    f64Number = Float64(f32Number * 0.0)
18
    f32Number = Float32(f64Number)        // f32Number = NaN
19

20
    return 0
21
}

从示例来看, round-to-nearest好像是 就近原则?

查了一下资料: 四舍六入五取偶: 溢出位<=4舍去, >=6进位, ==5看前一位的奇偶, 偶就进位, 奇就舍去

1. 高精度转低精度, 如果超出范围, 会变成无穷
2. 无穷只能转成无穷
3. NaN也只能转成NaN

d)有符号整数类型和无符号整数类型之间的双向转换:

因为任何有符号整数类型的表示范围 均不能 包含长度相同的无符号整数类型的表示范围(反之亦然), 因此它们之间进行转换时, 只要 待转换表达式的值落在目标整数类型的表示范围之内则转换成功, 否则根据上下文中的属性宏确定溢出处理策略(默认使用抛出异常的策略), 不同溢出策略详见[算术表达式]

下面以Int8和UInt8之间的转换为例进行说明(溢出时, 使用抛异常的处理策略):

1
main(){
2
    var i8Number: Int8 = 127
3
    var u8Number: UInt8 = 0
4

5
    u8Number = UInt8(i8Number)    // ok: u8Number = 127
6
    u8Number = 100
7
    i8Number = Int8(u8Number)    // ok: i8Number= 100
8
    i8Number= -100
9
    u8Number = UInt8(i8Number)    // throw an ArithmeticException
10
    u8Number = 255
11
    i8Number = Int8(u8Number)    // throw an ArithmeticException
12

13
    return 0
14
}

有符号和无符号整型之间转换, 如果没有溢出, 就获得最终值

如果存在溢出, 直接抛异常

e)整数转换为浮点数: 结果为尽可能接近原整数的浮点数

超出目标类型的表示范围时, 返回POSITIVE_INFINITY或NEGTIVE_INFINITY

f)浮点数转换为整数: 浮点类型到有符号整数类型的转换使用round-toward-zero模式, 即保留整数部分舍弃小数部分

当整数部分超出目标整数类型的表示范围, 则根据上下文中的整数溢出策略处理

如果是throwing策略, 那么抛出异常;

否则按如下规则转换:

• NaN返回0
• 小于整数取值范围下界时(包括负无穷), 返回整数的取值范围下界
• 大于整数取值范围上界时(包括正无穷), 返回整数的取值范围上界

1
main(){
2
    var i32Number: Int32 = 1024
3
    var f16Number: Float16 = 0.0
4
    var f32Number: Float32 = 0.0
5

6
    f16Number = Float16(i32Number)        // ok: f16Number = 1024.0
7
    f32Number = Float32(i32Number)        // ok: f32Number = 1024.0
8
    i32Number = 2147483647
9
    f16Number = Float16(i32Number)        // f16Number = POSITIVE_INFINITY    正无穷
10
    f32Number = Float32(i32Number)        // precision lost: f32Number = 2.14748365E9    精度丢失
11

12
    f32Number = 1024.1024
13
    i32Number = Int32(f32Number)        // ok: i32Number = 1024
14

15
    f32Number = 1024e10
16
    i32Number = Int32(f32Number)        // throw an Exception
17

18
    f32Number = 3.4e40                    // f32Number = POSITIVE_INFINITY
19
    i32Number = Int32(f32Number)        // throw an Exception
20

21
    f32Number = 3.4e40 * 0.0            // f32Number = NaN
22
    i32Number = Int32(f32Number)        // throw an Exception
23

24
    return 0
25
}

从示例来看:

1. 整数->浮点数

   如果超出了浮点数可表示的最大范围, 浮点数会变为无穷

   如果没有超出范围, 但是超出了精度范围, 就会丢失一定的精度

2. 浮点数->整数

   如果整数部分没有超出有效范围, 就取整

   如果整数部分超出有效范围, 就是溢出, 会抛异常

   如果浮点数是NaN或无穷, 也会抛异常

class/interface之间的类型转换#

对于一个class/interface类型的实例obj, 如果需要将它的(静态)类型转换到另一个class/interface类型TargetType, 可使用:obj as TargetType

关于as操作符的使用, 以及class/interface之间的类型转换规则, 参见[as 操作符]

虽然没有介绍, 但是推测应该与继承关系 有关系

类型别名定义的规则#

1. 类型别名的定义只能出现在top-level

   1
   func test(){
   2
       type Point2D = (Float64, Float64)                // error: type alias can only be defined at top-level
   3
       type Point3D = (Float64, Float64, Float64)        // error: type alias can only be defined at top-level
   4
   }
   

2. 用type定义类型别名时, 原类型必须在type定义的位置可见

   1
   class LongNameClassA {}
   2
   type ClassB = LongNameClassB            // error: use of undeclared type 'LongNameClassB'
   

3. 定义泛型别名时, 如果泛型别名中引入了原类型中没有使用的泛型参数, 则编译器会告警

   1
   type Class1<V> = GenericClassA<Int64, V>             // ok. ClassA is a generic class
   2
   type Class2<Value, V> = GenericClassB<Int64, V>     // warning: the type parameter 'Value' in 'Class2<Value, V>' is not used in 'GenericClassB<Int64, V>'
   3
   type Int<T> = Int32                                 // warning: the type parameter 'T' in 'Int<T>' is not used in`Int32`
   

仓颉中的type与C语言中的typedef有不同点

type只能用在顶层作用域, 不能出现在{}代码块中

而C/C++中的typedef可以出现在任何地方

4. 定义泛型别名时, 不允许为别名和原类型中的类型参数添加泛型约束, 在用到泛型别名时, 可以按需为其添加泛型约束

   另外, 原类型中已有的泛型约束会”传递”至别名

   1
   type Class1<V> where V <: MyTrait = GenericClassA<Int64, V>     // error: generic constraints are not allowed here
   2
   type Class2<V> = GenericClassB<Int64, V> where V <: MyTrait     // error: generic constraints are not allowed here
   3
   
   4
   type Class3<V> = GenericClassC<Int64, V>
   5
   func foo<V> (p: Class3<V>)where V <: MyTrait {                 // add generic constraints when 'Class3<V>' is used
   6
       functionBody
   7
   }
   8
   
   9
   class ClassWithLongName<T> where T<:MyTrait {
   10
       classBody
   11
   }
   12
   type Class<T> = ClassWithLongName<T>                           // Class<T> also has the constraint 'where T<:MyTrait'
   

别名只是起别名, 定义别名 不能额外添加原类型不存在的功能

但是使用时, 与原类型保持一致

5. 一个(或多个)type定义中禁止出现循环引用(无论是直接的或是间接的)

   其中, 判断循环引用的方式是通过名字判断是否存在循环引用, 并不是使用类型展开的方式

   1
   type Value = GenericClassAp<Int64, Value>        // error: 'Value' references itself
   2
   type Type1 = (Int64)->Type1                    // error: 'Type1' references itself
   3
   type Type2 = (Int64, Type2)                    // error: 'Type2' references itself
   4
   type Type3 = Type4                            // error: 'Type3' indirectlly references itself
   5
   type Type4 = Type3
   

6. 类型别名被视为与原类型等价的类型

   例如, 在下面的例子中, 可以将Int类型的参数和Int32类型的参数直接相加(Int定义为Int32的别名)

   注意, 不能通过使用别名达到函数重载的目的:

   1
   type Int = Int32
   2
   let numOne: Int32 = 10
   3
   let numTwo: Int = 20
   4
   let numThree = numOne + numTwo
   5
   
   6
   func add(left: Int, right: Int32): Int { left + right }
   7
   
   8
   func add(left: Int32, right: Int32): Int32 { left + right }     // error: invalid redeclaration of 'add : (Int32, Int32)->Int32'
   

7. type定义的默认可见性为default

   如果需要 在其他package内使用本package中定义的类型别名, 需要同时满足:

   (1)原类型在本package中的可见性修饰符为public

   (2)type定义使用public修饰符

   另外, 需要注意的是: 别名可以与原类型拥有不同的可见范围, 但是别名的的可见范围不能大于原类型的可见范围

   1
   package A
   2
   public class ClassWithLongNameA {
   3
   
   4
   }
   5
   class ClassWithLongNameB {
   6
   
   7
   }
   8
   
   9
   public type classA = ClassWithLongNameA            // ok
   10
   type classAInter = ClassWithLongNameA            // ok
   11
   
   12
   /* error: classB can not be declared with modifier 'public', as 'ClassWithLongNameB' is internal */
   13
   public type classB = ClassWithLongNameB
   14
   
   15
   // b.cj
   16
   package B
   17
   import A.*
   18
   let myClassA: A.classA = ClassWithLongNameA()
   

仓颉中type定义类型别名, 可以用可见性修饰符进行修饰

类型别名的使用#

类型别名可以用在任何等号右手边它指向的原类型能够使用的位置:

1. 作为类型使用, 例如:

   1
   type A = B
   2
   class B {}
   3
   var a: A = B()// Use typealias A as type B
   

2. 当类型别名实际指向的类型为class、struct时, 可以作为构造器名称使用

   1
   type A = B
   2
   class B {}
   3
   func foo(){ A()}  // Use type alias A as constructor of B
   

3. 当类型别名实际指向的类型为class、interface、struct时, 可以作为访问内部静态成员变量或函数的类型名

   1
   type A = B
   2
   class B {
   3
       static var b : Int32 = 0;
   4
       static func foo(){}
   5
   }
   6
   func foo(){
   7
       A.foo()// Use A to access static method in class B
   8
       A.b
   9
   }
   

4. 当类型别名实际指向的类型为enum时, 可以作为enum声明的构造器的类型名

   1
   enum TimeUnit {
   2
       Day | Month | Year
   3
   }
   4
   type Time = TimeUnit
   5
   var a = Time.Day
   6
   var b = Time.Month   // Use type alias Time to access constructors in TimeUnit
   

类型相等#

对于任意两个类型T1和T2, 如果它们满足以下任一条件, 则称T1和T2相等(记为T1 === T2):

• 存在类型别名定义type T1 = T2;
• 在class定义的内部和class的extend内部, T1是class的名字, T2是This;
• T1和T2的名字完全相同(自反性);
• T2 === T1(对称性);
• 存在类型Tk, 满足T1 === Tk且Tk === T2(传递性);

上面的所有情况的结论都是, T1 === T2, 也就是说每条之后都要加一句T1 === T2

第一眼只看每条句子, 一下子没看懂

子类型#

对于任意两个类型T1和T2, 如果它们满足以下任一条件, 则称T1是T2的子类型(记为T1 <: T2):

• T1 === T2;
• T1是Nothing类型;
• T1和T2均是Tuple类型, 并且T1每个位置处的类型都是T2对应位置处类型的子类型;
• T1和T2均是Function类型, 并且T2的参数类型是T1参数类型的子类型, T1的返回类型是T2返回类型的子类型;
• T1是任意class类型, T2是Object类型;
• T1和T2均是interface类型, 并且T1继承了T2;
• T1和T2均是class类型, 并且T1继承了T2;
• T2是interface类型, 并且T1实现了T2;
• 存在类型Tk, 满足T1 <: Tk且Tk <: T2(传递性)

只从说明可以看出, 仓颉中:

1. Nothing是所有类型的子类型

2. Object是所有class的子类型

3. 存在继承关系的class和interface类型, 被继承的类型(C++中的基类)是父类型, 子类是子类型

   即, 如果T1继承了T2, T1属于子类型

4. 如果两个interface, T1实现了T2, T1是T2的子类型

   可以看作是T2生出了T1

最小公共父类型#

在有子类型的类型系统里, 有时会遇到需要求两个类型的最小公共父类型的情形, 例如 if表达式的类型便是其两个分支的类型的最小公共父类型, match表达式类似

两个类型的最小公共父类型, 是其公共父类型中最小的一个

最小意味着它是其他所有公共父类型的子类型

最小公共父类型定义如下:

对于任意两个类型T1和T2, 如果类型LUB满足如下规则, 则LUB是T1和T2的最小公共父类型:

• 对于同时满足T1 <: T和T2 <: T的任意类型T, LUB <: T也成立

注意, 如果公共父类型中的某个类型不比其他类型大, 它只是极小的, 并不一定是最小的

参考数学中的集合

最大公共子类型#

因为子类型关系中存在逆变(定义参考泛型章节下的类型型变)的情形, 如函数类型的参数类型是逆变的, 此时会需要求两个类型的最大公共子类型

两个类型的最大公共子类型, 是其公共子类型中最大的一个

最大意味着它是其他所有公共子类型的父类型

最大公共子类型定义如下: 对于任意两个类型T1和T2, 如果类型GLB满足如下规则, 则GLB是T1和T2的最大公共子类型:

• 对于同时满足T <: T1和T <: T2的任意类型T, T <: GLB也成立

注意, 如果公共子类型中的某个类型不比其他类型小, 它只是极大的, 并不一定是最大的

同样参考数学中的集合