Kotlin

Question

我有一段 Kotlin 代码，其中第一个和第二个构造函数略有不同，见下文

class InstructionPrototype constructor(
      val iname: String,
      val opcode: Int,
      val mnemonicExample: String,
      val numericExample: Int,
      val description: String,
      val format: Format,
      val pattern: Pattern,
      var type: Type? = null,
      var rt: Int? = null,
      var funct: Int? = null,
      var conditions: Array<(n: Int) -> String?>? = null) {
  constructor(
        iname: String,
        opcode: Int,
        mnemonicExample: String,
        numericExample: Int,
        description: String,
        format: Format,
        pattern: Pattern,
        type: Type?,
        rt: Int?,
        funct: Int?,
        condition: (n: Int) -> String?
  ): this(iname, opcode, mnemonicExample, numericExample, description, 
        format, pattern, type, rt, funct, arrayOf(condition)) {

  }

是否可以通过某种语言结构来减少它的冗长程度？我在考虑代数数据类型，但感觉不太合适——它看起来像 "hacky"。

Answer 1

Variable number of arguments (vararg) 似乎非常适合您的用例，但前提是您可以放弃 null 作为 conditions 的默认值，因为 vararg 不能为空（例如使用 emptyArray()):

class InstructionPrototype constructor(
      val iname: String,
      val opcode: Int,
      val mnemonicExample: String,
      val numericExample: Int,
      val description: String,
      val format: Format,
      val pattern: Pattern,
      var type: Type? = null,
      var rt: Int? = null,
      var funct: Int? = null,
      vararg var conditions: (n: Int) -> String? = emptyArray())

在使用现场，可以传单(n: Int) -> String?，会打包成一个数组，而且，除了传几个用逗号隔开的函数外，还可以用spread operator 传递一个数组：

f(vararg a: String) { }

f("a")
f("a", "b", "c")

val array = arrayOf("a", "b", "c")
f(*array) // any array of the correct type can be passed as vararg

此外，conditions 之前的几个参数也有默认值，除了使用 named arguments 和展开运算符之外，没有其他方法可以跳过它们并传递 conditions：

fun f(x: Int = 5, vararg s: String) { }

f(5, "a", "b", "c") // correct
f(s = "a") // correct
f(s = "a", "b", "c") // error
f(s = *arrayOf("a", "b", "c") // correct

Kotlin - 有一个参数不同的辅助构造函数

Kotlin - Secondary constructor that differs by one argument

verbosity

boilerplate