联合类型(sum types)

定义联合类型

V的联合类型在V编译器代码中大量采用

有些使用接口的场景,不一定要全部用接口来实现,使用联合类型的代码看起来更简洁,清晰

相对于go和rust来说,联合类型给V加分不少,用起来很舒服

语法类似typescript，使用type 和 | 来定义一个联合类型

  1.  //定义联合类型,表示类型Expr可以是这几种类型的其中一种
  2. type Expr = Foo | BoolExpr |  BinExpr | UnaryExpr

使用pub关键字,定义公共的联合类型

  1. pub type Expr = Foo | BoolExpr |  BinExpr | UnaryExpr

使用场景

联合类型相对于接口来说,比较适合于一个类型是已知的几种类型的其中一种,已知类型的数量是有限的,固定的,相对封闭的,不需要考虑未知类型的扩展性

比如,x.json2模块中,使用联合类型来包含所有json的节点类型,json节点类型种类是相对固定的,使用了联合类型这种数据结构来表示,后续的代码就变得很简洁清晰

  1. //代码位置:vlib/x/json2/decoder.v
  2. pub type Any = string | int | i64 | f32 | f64 | any_int | any_float | bool | Null | []Any | map[string]Any

还有另一个最大的场景就是V编译器自身,使用了联合类型来包含所有的AST抽象语法树的类型,毕竟AST的节点类型也是有限的,固定的,相对封闭的,后续AST的逻辑代码也变得简洁清晰很多

  1. //代码位置:vlib/v/ast/ast.v
  2. pub type TypeDecl = AliasTypeDecl | FnTypeDecl | SumTypeDecl | UnionSumTypeDecl
  4. pub type Expr = AnonFn | ArrayInit | AsCast | Assoc | AtExpr | BoolLiteral | CTempVar |
  5.     CallExpr | CastExpr | ChanInit | CharLiteral | Comment | ComptimeCall | ConcatExpr | EnumVal |
  6.     FloatLiteral | Ident | IfExpr | IfGuardExpr | IndexExpr | InfixExpr | IntegerLiteral |
  7.     Likely | LockExpr | MapInit | MatchExpr | None | OrExpr | ParExpr | PostfixExpr | PrefixExpr |
  8.     RangeExpr | SelectExpr | SelectorExpr | SizeOf | SqlExpr | StringInterLiteral | StringLiteral |
  9.     StructInit | Type | TypeOf | UnsafeExpr
  11. pub type Stmt = AssertStmt | AssignStmt | Block | BranchStmt | CompFor | ConstDecl | DeferStmt |
  12.     EnumDecl | ExprStmt | FnDecl | ForCStmt | ForInStmt | ForStmt | GlobalDecl | GoStmt |
  13.     GotoLabel | GotoStmt | HashStmt | Import | InterfaceDecl | Module | Return | SqlStmt |
  14.     StructDecl | TypeDecl

而接口更适合用来支持未知类型的扩展性

使用联合类型

  • 联合类型作为函数的参数或返回值,也可以作为变量声明,结构体字段
  • 使用match语句,进行类型的进一步判断
  • 使用match语句,如果需要修改联合类型的值,需要在变量前加mut
  • 使用is关键字联合类型具体是哪一种类型
  • 使用as关键字将联合类型转换为另一种类型,当然要转换的类型在联合类型定义的类型范围内
  1. module main
  3. struct User {
  4.     name string
  5.     age  int
  6. }
  8. fn (m &User) str() string {
  9.     return 'name:$m.name,age:$m.age'
  10. }
  12. // 联合类型声明
  13. type MySum = User | int | string
  15. fn (ms MySum) str() string {
  16.     if ms is int { // 使用is关键字,判断联合类型具体是哪种类型
  17.         println('ms type is int')
  18.     }
  19.     match ms { // 对接收到的联合类型,使用match语句进行类型判断,每个match分支的ms变量都会被自动造型为分支中对应的类型
  20.         int { return ms.str() }
  21.         string { return ms }
  22.         User { return ms.str() }
  23.     }
  24. }
  26. fn add(ms MySum) { // 联合类型作为参数
  27.     match ms { // 可以对接收到的联合类型,使用match语句进行类型判断,每个match分支的ms变量都会被自动造型为分支中对应的类型
  28.         int { println('ms is int,value is $ms') }
  29.         string { println('ms is string,value is $ms') }
  30.         User { println('ms is User,value is $ms.str()') }
  31.     }
  32. }
  34. fn sub(i int, s string, u User) MySum { // 联合类型作为返回值
  35.     return i
  36.     // return s //这个也可以
  37.     // return User{name:'tom',age:3} //这个也可以
  38. }
  40. fn main() {
  41.     i := 123
  42.     s := 'abc'
  43.     u := User{
  44.         name: 'tom'
  45.         age: 33
  46.     }
  47.     mut res := MySum{} // 声明联合类型变量
  48.     res = i
  49.     println(res) // 输出123
  50.     res = s
  51.     println(res) // 输出abc
  52.     res = u
  53.     println(res) // 输出name:tom,age:33
  54.     match res { // 判断具体类型
  55.         int { println('res is:$res.str()') }
  56.         string { println('res is:$res') }
  57.         User { println('res is:$res.str()') }
  58.     }
  59.     match mut res { // 如果需要在分支中修改res,需要加mut
  60.         int {
  61.             res = MySum(3)
  62.             println('new res value is: $res')
  63.         }
  64.         string {
  65.             res = 'abc'
  66.             println('new res value is: $res')
  67.         }
  68.         User {
  69.             res = User{
  70.                 name: 'jack'
  71.                 age: 12
  72.             }
  73.             println('new res value is:$res.str()')
  74.         }
  75.     }
  76.     user := res as User // 也可以通过as,进行显示造型
  77.     println(user.name)
  78.     add(i)
  79.     add(s)
  80. }

获取联合类型的具体类型

联合类型使用内置方法type_name()来返回变量的具体类型

  1. module main
  3. struct Point {
  4.     x int
  5. }
  7. type MySumType = Point | f32 | int
  9. fn main() {
  10.     // 联合类型使用type_name()
  11.     sa := MySumType(32)
  12.     sb := MySumType(f32(123.0))
  13.     sc := MySumType(Point{
  14.         x: 43
  15.     })
  16.     println(sa.type_name()) // int
  17.     println(sb.type_name()) // f32
  18.     println(sc.type_name()) // Point
  19. }

联合类型相等判断

  1. type Str = string | ustring
  3. struct Foo {
  4.     v int
  5. }
  7. struct Bar {
  8.     v int
  9. }
  11. type FooBar = Foo | Bar
  13. fn main() {
  14.     s1 := Str('s')
  15.     s2 := Str('s')
  16.     u1 := Str('s'.ustring())
  17.     u2 := Str('s'.ustring())
  18.     println( s1 == s1 ) //联合类型判断相等或不等:同类型,同值
  19.     println( s1 == s2 )
  20.     println( u1 == u1 )
  21.     println( u1 == u2 )
  23.     //类型不同,值相同也不等
  24.     foo := FooBar( Foo{v: 0} )
  25.     bar := FooBar( Bar{v: 0} )
  26.     println( foo.v == bar.v )
  27.     println( foo != bar )
  28. }

for is类型循环判断

用于联合类型的类型循环判断(感觉没啥用,就是一个语法糖而已)

  1. module main
  3. struct Milk {
  4. mut:
  5.     name string
  6. }
  8. struct Eggs {
  9. mut:
  10.     name string
  11. }
  13. type Food = Eggs | Milk
  15. fn main() {
  16.     mut f := Food(Eggs{'test'})
  17.     //不带mut
  18.     for f is Eggs {
  19.         println(typeof(f).name)
  20.         break
  21.     }
  22.     //等价于
  23.     for {
  24.         if f is Eggs {
  25.             println(typeof(f).name)
  26.             break
  27.         }
  28.     }
  29.     //带mut
  30.     for mut f is Eggs {
  31.         f.name = 'eggs'
  32.         println(f.name)
  33.         break
  34.     }
  35.     //等价于
  36.     for {
  37.         if mut f is Eggs {
  38.             f.name = 'eggs'
  39.             println(f.name)
  40.             break
  41.         }
  42.     }
  43. }

as类型转换

  1. module main
  3. type Mysumtype = bool | f64 | int | string
  5. fn main() {
  6.     x := Mysumtype(3)
  7.     x2 := x as int
  8.     println(x2)
  9. }

联合类型嵌套

联合类型还可以嵌套使用,支持更复杂的场景

  1. struct FnDecl {
  2.     pos int
  3. }
  5. struct StructDecl {
  6.     pos int
  7. }
  10. struct IfExpr {
  11.     pos int
  12. }
  14. struct IntegerLiteral {
  15.     val string
  16. }
  18. type Expr = IfExpr | IntegerLiteral
  19. type Stmt = FnDecl | StructDecl
  20. type Node = Expr | Stmt //联合类型嵌套

联合类型方法

可以像结构体那样,给联合类型添加方法

  1. module main
  3. fn main() {
  4.     mut m := Mysumtype{}
  5.     m = int(11)
  6.     println(m.str())
  7. }
  9. type Mysumtype = int | string
  11. pub fn (mysum Mysumtype) str() string { // 联合类型的方法
  12.     return 'from mysumtype'
  13. }

访问公共字段

联合类型可以在方法中访问所有类型的公共字段,并且支持联合类型的多级嵌套

截图中是实际的V编译器中的例子:

stmt.pos是所有Stmt联合类型的公共字段,有了这个特性以后,代码就可以简洁到像截图中的第一个方法那样

图像

联合类型作为结构体字段

结构体字段的类型也可以是联合体类型

  1. struct MyStruct {
  2.     x int
  3. }
  5. struct MyStruct2 {
  6.     y string
  7. }
  9. type MySumType = MyStruct | MyStruct2
  11. struct Abc {
  12.     bar MySumType // bar字段的类型也可以是联合类型
  13. }
  15. fn main() {
  16.     x := Abc{
  17.         bar: MyStruct{123}
  18.     }
  19.     if x.bar is MyStruct {
  20.         println(x.bar)
  21.     }
  22.     match x.bar { // match匹配也可以使用
  23.         MyStruct { println(x.bar.x) } // 也会自动造型为具体类型
  24.         else {}
  25.     }
  26. }

子类不允许是指针类型

使用联合类型时,有一点需要注意:联合类型的子类中不允许出现指针类型,编译器会检查并报错

  1. struct Abc {
  2.     val string
  3. }
  5. struct Xyz {
  6.     foo string
  7. }
  9. type Alphabet1 = Abc | string | &Xyz //不允许指针类型