函数修饰符#

命名形参#

函数定义时通过 在形参名后添加 ! 来定义命名形参

1
namedParameter
2
    : identifier '!' ':' type
3
    ;

• 函数定义时, 命名形参后不允许有非命名形参

  1
  func add1(a: Int32, b!: Int32): Int32 { a + b } // ok
  2
  
  3
  func add2(a!: Int32, b: Int32): Int32 { a + b } // error
  

• 当形参被定义成命名形参后, 调用这个函数时, 则必须在实参值前使用参数名: 前缀来指定这个实参对应的形参, 否则编译报错

  1
  func add(a: Int32, b!: Int32): Int32 { a + b }
  2
  
  3
  add(1, b: 2) // ok
  4
  add(1, 2)    // error
  

• 如果抽象函数或 open 修饰的函数有命名形参, 那么实现函数或 override 修饰的函数也需要保持同样的命名形参

  1
  open class A {
  2
      public open func f(a!: Int32): Int32 {
  3
          return a + 1
  4
      }
  5
  }
  6
  class B <: A {
  7
      public override func f(a!: Int32): Int32 { // ok
  8
          return a + 1
  9
      }
  10
  }
  11
  class C <: A {
  12
      public override func f(b!: Int32): Int32 { // error
  13
          return b + 1
  14
      }
  15
  }
  

仓颉中, 如果函数存在命名参数, 则必须通过参数名: 值来进行传参

参数的默认值#

函数的参数可以有默认值, 通过=来为参数定义默认值

当默认值被定义后, 调用这个函数可以忽略这个参数, 函数体会使用默认值

为了便于理解, 有默认值的参数称为可选参数

函数定义时, 可选参数是一种命名形参, 可选参数名后必须添加!, 否则编译报错;

1
defaultParameter
2
    : identifier '!' ':' type '=' expression
3
    ;

如下示例, 我们定义了一个add函数, 它的参数类型列表(Int32, Int32)

函数定义时, b具有默认值1

因此, 当我们调用add函数, 并且只传递一个值3时, 3会被赋值给a, 从而返回结果4

如果传入两个值3和2, 那么b的值为2

1
func add(a: Int32, b!: Int32 = 1): Int32 { a + b }
2

3
add(3)            // invoke add(3, 1), return 4
4
add(3, b: 2)    // return 5

了解过 C++的话, 仓颉中存在默认值参数的使用, 也没有太大区别

• 类或接口中被 open 关键字修饰的函数不允许有可选参数

• 操作符函数不允许有可选参数

• 匿名函数(lambda 表达式)不允许有可选参数

• 函数参数默认值中引入的名字从静态作用域中获得, 即引入的名字为函数定义时可访问到的名字

• 函数参数默认值中引入的名字在函数定义时可访问即可, 无需和函数本身的可访问性一致

• 函数参数和其默认值不属于该函数的函数体

• 参数默认值在函数调用时求值, 而非在函数定义时求值

• 规定, 函数调用时参数求值顺序是按照定义时顺序从左到右, 函数参数的默认值可以引用定义在该参数之前的形参

• 函数调用时, 通过函数名调用可以使用默认值, 通过变量名调用不支持使用默认值

  1
  // 编译时错误
  2
  // func f(a: Int32, b!: Int32 = 2, c: Int32): Int32 { ... }
  3
  
  4
  // OK.
  5
  func f1(a: Int32, b: Int32, c!: Int32 = 3, d!: Int32 = 4): Int32 {
  6
      a + b + c + d
  7
  }
  8
  
  9
  func test() {
  10
      f1(1, 2)            // 10,  f1(1, 2, 3, 4)
  11
      f1(1, 2, c: 5)        // 12,  f1(1, 2, 5, 4)
  12
  }
  

  1
  /* 在默认值中引入的名称, 不需要具有与函数相同或更严格的可访问性 */
  2
  var x = 10
  3
  var y = 10
  4
  func g() {}
  5
  public func f2(a!: Int64 = x * 2 + y, b!: ()->Unit = g) {}  // OK.
  6
  
  7
  class AAA {
  8
      static private var x = 10
  9
  
  10
      func f(a!: Int64 = x) { // OK, public 方法可以使用私有静态字段
  11
          print("${a}")
  12
          x = x + 10
  13
          print("${x}")
  14
      }
  15
  }
  

  1
  /*
  2
  调用函数时, 函数声明中的名称可以使用默认值
  3
  使用变量名调用函数时, 参数不能是可选的, 即不支持使用默认值
  4
  */
  5
  func f1(): (Int64) -> Unit { g1 }
  6
  
  7
  func g1(a!: Int64 = 42) {
  8
      print("g1: ${a}")
  9
  }
  10
  
  11
  let gg1 = f1()
  12
  let x = gg1()    // Error, 不能省略参数
  13
  let gg3 = g1
  14
  let a = gg3()    // Error, 不能省略参数
  

文档中有两句比较不明确的介绍:

• 函数参数默认值中引入的名字从静态作用域中获得, 即引入的名字为函数定义时可访问到的名字
• 函数参数默认值中引入的名字在函数定义时可访问即可, 无需和函数本身的可访问性一致

这两句话的意思其实是:

函数参数的默认值表达式中所引用的名字(变量、函数等), 按照静态作用域规则在函数定义处进行解析, 即 解析的是函数定义时可以看到的名字, 而不是调用时可能可以看到的名字

只要在该位置这些名字是可访问的(无论其访问权限是 private 还是 public), 就可以使用, 不要求默认值中引用的名字具有 与函数定义本身的访问级别(如 public) 相同或更宽松的访问权限

在例子中就是, public成员函数可以引用private成员变量作为参数的默认值

由于函数的形参和其默认值不属于该函数的函数体

所以下面例子中的 return 表达式缺少包围它的函数体

它既不属于外层函数 f(因为内层函数定义 g 已经开始), 也不在内层函数 f 的函数体中:

1
func f() {
2
    func g(x! :Int64 = return) { // Error: return 必须在函数体内使用
3
        0
4
    }
5
    1
6
}

这个意思是, 仓颉中函数体 就只是{}的内容, 参数列表什么的都是不算的

局部变量#

在仓颉编程语言中, 允许在函数体内定义变量, 将其称为局部变量

变量可以用var修饰为可变变量或let修饰为不可变变量

1
func foo(): Unit {
2
    var a = 1
3
    let b = 1
4
}

熟悉 C/C++, 对局部变量再熟悉不过了

嵌套函数#

在仓颉编程语言中, 允许在函数体内定义函数, 将其称为嵌套函数

嵌套函数中可以捕获外部函数中定义的变量或其他嵌套函数

嵌套函数支持递归

1
func foo(): Unit {
2
    func add(a: Int32, b: Int32) {
3
        a + b
4
    }
5

6
    let c = 1
7

8
    func nest(): Unit {
9
        print("${c}")        // 1
10
        var b = add(1, 2)    // b = 3
11
    }
12
}

仓颉中, 嵌套函数就是在函数体内定义函数

嵌套函数 可以捕获外部函数定义的变量或其他嵌套函数, 其实与顶层作用域定义函数相似

命名实参#

命名实参是指在函数调用时, 在实参值前使用 形参名 : 前缀来指定这个实参对应的形参

只有在函数定义时使用!定义的命名形参, 才可以在调用时使用命名实参的语法

函数调用时, 所有的命名形参均必须使用命名实参来传参, 否则报错

在函数调用表达式中, 命名实参后不允许出现非命名实参

使用命名实参指定实参值时, 可以不需要和形参列表的顺序保持一致

1
func add(a!: Int32, b!: Int32): Int32 {
2
    a + b
3
}
4

5
var sum1 = add(1, 2)        // error
6
var sum2 = add(a: 1, b: 2)  // OK, 3
7
var sum3 = add(b: 2, a: 1)  // OK, 3

因为函数定义时, 命名形参之后不允许出现非命名形参, 所以后面所有的命名形参都可以不按照参数列表顺序进行传参

函数调用类型检查#

本节介绍的是, 给定一个调用表达式, 对调用表达式所需要进行的类型检查

如果被调用的函数涉及重载, 则需要根据函数重载的规则进行类型检查和重载决议

1. 如果函数调用表达式中指定了类型参数, 只有类型实参的个数与类型形参的个数相同才可能通过类型检查, 即假设函数调用表达式为: f<T1, ..., Tm>(A1, ..., An), 其中给定了 m 个类型实参, 则函数类型形参数量须为 m

   1
   open class Base {}
   2
   class Sub <: Base {}
   3
   
   4
   func f<X, Y>(a: X, b: Y) {}    // f1
   5
   func f<X>(a: Base, b: X) {}    // f2
   6
   
   7
   f<Base>(Base(), Sub())        // f2 may pass the type checking
   

2. 根据调用表达式中的实参 和 调用表达式所在的类型检查上下文中 指定的返回类型 R 对函数进行类型检查

   假设函数定义为:

   $$f_i<T_{i1}, ..., T_{ip}>(A_{i1}, ..., A_{ik}):R_i\ where\ C_{i1}, ..., C_{iq_i}$$

   1. 如果调用表达式带了类型实参: fi<T1, ..., Tp>(A1, ..., Ak), 那么对于函数fi的类型检查规则如下:

      1. 类型实参约束检查: 类型实参 <T1, ..., Tp> 需要满足函数 fi 的类型约束

         $$\begin{aligned} &σ=[T_1↦T_{i1},...,T_p↦T_{ip}] \\ &Δ⊢σ\ \ solves\ \ C_{i1},...,C{iq_i} \end{aligned}$$

      2. 参数类型检查: 将类型实参代入函数 fi 的形参后, 满足实参类型 (A1, ..., Ak) 是类型实参代入形参后类型的子类型

         $$\begin{aligned} &σ=[T_1↦T_{i1},...,T_p↦T_{ip}] \\ &Δ⊢(A_1,...,A_k)<:σ(A_{i1},...,A_{ik}) \end{aligned}$$

      3. 返回类型检查: 如果调用表达式的上下文对其有明确类型要求R, 则需要根据返回类型进行类型检查, 将类型实参代入函数 fi 的返回类型 Ri 后, 满足类型实参代入后的返回类型是 R 的子类型

         $$\begin{aligned} &σ=[T_1↦T_{i1},...,T_p↦T_{ip}] \\ &Δ⊢σR_i<:R \end{aligned}$$

   2. 如果调用表达式不带类型实参: f(A1, ..., An), 那么对于函数fi的类型检查规则如下:

      1. 如果**fi是非泛型函数**, 则按如下规则进行类型检查:

         1. 参数类型检查: 实参类型 (A1, ..., Ak) 是形参类型的子类型

            $$Δ⊢(A_1,...,A_k)<:(A_{i1},...,A_{ik})$$

         2. 返回类型检查: 如果调用表达式的上下文对其有明确类型要求 R, 则检查函数 fi 的返回类型 Ri 是 R 的子类型

            $$Δ⊢R_i<:R$$

            1
            open class Base {}
            2
            class Sub <: Base {}
            3
            func f(a: Sub) {1}        // f1
            4
            func f(a: Base) {Base()}    // f2
            5
            let x: Base = f(Sub())    // f2 can pass the type checking
            

      2. 如果 fi是泛型函数, 则按如下规则进行类型检查:

         1. 参数类型检查: 存在代换使得实参类型(A1, ..., Ak)是形参类型代换后的类型的子类型

            $$\begin{aligned} &σ=[T_1↦T_{i1},...,T_p↦T_{ip}] \\ &Δ⊢(A_1,...,A_k)<:σ(A_{i1},...,A_{ik}) \end{aligned}$$

         2. 返回类型检查: 如果调用表达式的上下文对其有明确类型要求R, 则需要根据返回类型进行类型检查, 将 a) 中的代换代入函数fi的返回类型Ri后, 满足代换后的返回类型是R的子类型

            $$\begin{aligned} &σ=[T_1↦T_{i1},...,T_p↦T_{ip}] \\ &Δ⊢σR_i<:R \end{aligned}$$

需要注意的是:

1. 如果函数有缺省值, 在类型检查时会补齐缺省值之后再进行类型检查;
2. 如果函数有命名参数, 命名参数的顺序可能会和形参顺序不一致, 在类型检查时, 命名实参要与名字匹配的命名形参对应

总结几点就是:

1. 泛型函数, 传入的类型实参数量 需要与 目标泛型函数的类型形参数量 保持一致

2. 泛型函数, 如果显式传入类型实参, 则会:

   1. 进行类型约束的检查, 即 判断是否满足 函数定义时 对实参类型指定的约束条件(where 条件)
   2. 类型实参传入之后, 函数调用实参的类型要满足 是传入类型实参的子类型
   3. 根据传入类型实参, 检查最终的返回值类型 是否满足 函数定义的返回类型的子类型

3. 如果不显式传入类型实参, 则有可能是非泛型函数

   1. 如果是非泛型函数, 则会:

      1. 检查函数调用实参类型 是否满足 函数定义的形参类型的子类型
      2. 检查返回值类型 是否满足 函数定义的返回类型的子类型

   2. 如果是泛型函数, 则会:

      1. 检查调用参数类型

         根据函数调用传入的实参类型, 推导类型代换 σ(上面的类型映射数学公式), 使得实参类型满足代换后的形参类型

         即 传入的实参的类型, 属于函数形参类型的子类型

      2. 检查返回类型

         还是根据推导和代换的形参类型, 去推导最后的返回值类型 是否满足 函数定义的返回类型的子类型

文本上比较绕, 但其实核心很简单: 根据实参类型推导、代换形参类型, 再根据形参类型 进行实际的参数检查、返回值类型检查等操作

尾随Lambda#

当函数最后一个形参是函数类型, 并且函数调用对应的实参是 lambda 时, 我们可以使用尾随 lambda 语法, 将 lambda 放在函数调用的尾部, 括号外面

1
func f(a: Int64, fn: (Int64)->Int64) {
2
    fn(a)
3
}
4
f(1, { i => i * i })       // 普通函数调用
5
f(1) { i => i * i }        // 尾随 lambda
6

7
func g(a!: Int64, fn!: (Int64)->Int64) {
8
    fn(a)
9
}
10
g(a: 1, fn: { i => i * i })   // 普通函数调用
11
g(a: 1) { i => i * i }        // 尾随 lambda

当函数调用有且只有一个 lambda 实参时, 我们还可以省略 (), 只写 lambda

1
func f(fn: (Int64)->Int64) {
2
    fn(1)
3
}
4

5
f{ i => i * i }

如果尾随 lambda 不包含形参, => 可以省略

1
func f(fn: ()->Int64) {
2
    fn()
3
}
4

5
f{ i * i }

需要注意的是, 尾随 lambda 语法只能用在具有 函数名/变量名 的函数调用上, 并且尾随 lambda 的 lambda 表达式只会解释为 函数名/变量名 对应的函数的参数

这意味着以下两种调用例子是不合法的:

1
func f(): (()->Unit)->Unit {
2
    {a => }
3
}
4

5
f() {}                                // Error, lambda 表达式不是 f 的参数
6

7
func g(a: ()->Unit) {}
8

9
if (true) { g } else { g } () {}      // Error, 非法尾随 lambda 语法

必须先将以上的表达式赋值给变量, 使用变量名调用时才可以使用尾随 lambda 语法

如下面的代码所示:

1
let f2 = f()
2
f2 {}          // ok
3

4
let g2 = if (true) { g } else { g }
5
g2() {}        // ok

普通函数调用和构造函数调用都可以使用这个语法, 包含 this() 和 super()

1
this(1, { i => i * i } )
2
this(1) { i => i * i }
3

4
super(1, { i => i * i } )
5
super(1) { i => i * i }

仓颉中, 如果函数的最后一个形参类型为函数类型, 就可以使用尾随Lambda语法

即, 实参可以正常传入lambda表达式, 也可以正常函数调用之后(不传入lambda), 跟上一个{lambda}来实现尾随lambda

1
func f(param1: Int64, param2: Int64, lam: (Int64, Int64)->Int64) {
2
    lam(param1, param2)
3
}
4

5
f(1, 2, { p1, p2 => p1 * p2 })    // 普通函数调用
6
f(1, 2) { p1, p2 => p1 * p2}      // 尾随 lambda

这是一个在 C/C++中从未见过的lambda表达式传参方法

变长参数#

变长参数是一种特殊的函数调用语法糖, 当形参最后一个非命名参数是 Array 类型时, 实参中对应位置可以直接传入参数序列代替 Array 字面量

1. 变长参数没有特殊的声明语法, 只要求函数声明处最后一个非命名参数是 Array 类型

2. 变长参数在函数调用时可以使用普通参数列表的形式逐个传入 Array 的多个元素

3. 非命名参数中, 只有最后一个位置的参数可以使用变长参数

   命名参数不能使用这个语法糖

4. 变长参数对全局函数、静态成员函数、实例成员函数、局部函数、构造函数、函数变量、lambda、函数调用操作符重载、索引操作符重载的调用都适用, 不支持其它操作符重载、compose、pipeline 这几种调用方式

5. 变长参数的个数可以是 0 个或以上

6. 变长参数只有在函数重载所有情况都不匹配的情况下, 才判断是否可以应用语法糖, 优先级最低

1
func f1(arr: Array<Int64>) {}
2
func f2(a: Int64, arr: Array<Int64>) {}
3
func f3(arr: Array<Int64>, a: Int64) {}
4
func f4(arr1!: Array<Int64>, a!: Int64, arr2!: Array<Int64>) {}
5

6
func g() {
7
    let li = [1, 2, 3]
8
    f1(li)
9
    f1(1, 2, 3)                           // 使用变长参数
10
    f1()                                  // 使用变长参数
11
    f2(4, li)
12
    f2(4, 1, 2, 3)                        // 使用变长参数
13

14
    f3(1, 2, 3)                           // Error, Array 不是最后一个参数
15
    f4(arr1: 1,2,3, a: 2, arr2: 1,2,3)    // Error, 命名参数不能使用变长参数
16
}

仓颉中, 只要函数定义的最后一个参数是Array类型的, 那么就可以当作变长参数使用

当然也可以直接传入Array类型的数据

函数重载决议总是会优先考虑不使用变长参数就能匹配的函数, 只有在所有函数都不能匹配, 才尝试使用变长参数解析

当编译器无法决议时会报错

1
open class A {
2
    func f(v: Int64): Unit {          // f1
3
    }
4
}
5

6
class B <: A {
7
    func f(v: Array<Int64>): Unit {   // f2
8
    }
9
}
10

11
func p1() {
12
    let x = B()
13
    x.f(1)                            // call the f1
14
}
15

16
func g<T>(arg: T): Unit {             // g1
17
}
18

19
func g(arg: Array<Int64>): Unit {     // g2
20
}
21

22
func p2() {
23
    g(1)                              // call the g1
24
}
25

26
func h(arg: Any): Unit {              // h1
27
}
28
func h(arg: Array<Int64>): Unit {     // h2
29
}
30

31
func p3() {
32
    h(1)                              // call the h1
33
}

如果使用变长参数的函数存在重载, 那么编译器会优先决议使用不使用变长参数的版本

函数作用域#

在仓颉编程语言中, 函数可以在源程序顶层定义或者在函数内部定义:

• 全局函数

  在源程序顶层定义函数称为全局函数, 它的作用域是全局的

  如下示例, 函数 globalFunction 是全局函数

  它的作用域是全局作用域

  1
  func globalFunction() {}
  

• 嵌套函数

  在函数体内部定义的函数成为嵌套函数, 它的作用域是局部的, 详见[作用域]

  如下示例, 函数 nestedFunction 是嵌套函数, 它的作用域是从定义之后开始, 到 globalFunction 函数体结束

  1
  func globalFunction() {
  2
      func nestedFunction() {}
  3
  }
  

• 成员函数

  在类型定义中可以声明或定义成员函数

  成员函数的作用域是整个类型及其扩展

  1
  interface Myinterface {
  2
      func foo(): Unit
  3
      static func bar(): Unit
  4
  }
  5
  
  6
  class MyClass {
  7
      func foo() {}
  8
      static func bar() {}
  9
  }
  

• 扩展成员函数

  在扩展中可以声明额外的成员函数

  它的作用域是被扩展类型的所有扩展, 同时受访问修饰符限制

  1
  extend MyType {
  2
      func foo(): Unit {}
  3
  }
  

如果你了解过任意一门有面向对象思想的编程语言, 这一部分应该没有什么特别的问题