在 Kotlin 中实现访问者模式的最佳方法

Question

在 Kotlin 中实现 visitor pattern 是否有任何技巧或常用方法？任何对初学者来说可能不明显但会导致代码更简洁或有条理的东西。

为澄清而编辑：我有一个 AST，其中包含许多 (~30) 类型的节点。目前，每个类都实现了自己的 print() 方法，我想将其分解为单独的 Printer 类。有了访问者模式，添加其他 AST 遍历类会更简洁，其中会有几个。

Answer 1

阅读this answer 了解 Java 8，它所说的一切也适用于 Kotlin：

对 Java 语言的添加不会使每个旧概念都过时。事实上，访问者模式非常擅长支持添加新操作。

这适用于 Kotlin。与 Java 8 一样，它具有 Lambdas、SAM conversions 和 interfaces that allow default implementations。

一个变化是，如果您要进行类实例类型检查，而不是对每个 instanceof 检查使用大的 if 语句，请在 Kotlin 中使用 when expression：

在不同答案的同一个 Stackoverflow 页面上，它谈到了正在使用的 Lambda，并在 Java 中显示 if 语句来决定调用哪个 lambda。而不是他们的Java sample：

if (animal instanceof Cat) {
    catAction.accept((Cat) animal);
} else if (animal instanceof Dog) {
    dogAction.accept((Dog) animal);
} else if (animal instanceof Fish) {
    fishAction.accept((Fish) animal);
} else if (animal instanceof Bird) {
    birdAction.accept((Bird) animal);
} else {
    throw new AssertionError(animal.getClass());
}

使用这个 Kotlin：

when (animal) {
    is Cat -> catAction.accept(animal)
    is Dog -> dogAction.accept(animal)
    is Fish -> fishAction.accept(animal)
    is Bird -> birdAction.accept(animal)
    else -> throw AssertionError(animal.javaClass)
}

在 Kotlin 中，您不需要强制转换，因为当编译器看到 is 检查实例类型时会自动生成 smart cast。

同样在 Kotlin 中，您可以使用 Sealed Classes 来表示层次结构中的可能选项，然后编译器可以确定您是否已用尽所有情况，这意味着您不需要 when 语句中的 else。

否则，该页面上适用的内容以及同一问题的其他常见答案对 Kotlin 来说是很好的信息。我认为在 Java 8、Scala 或 Kotlin 中看到实际的字面访问者模式并不常见，而是使用 lambda 和/或模式匹配的一些变体。

其他相关文章：

• Visitor pattern with Java 8 default methods（Kotlin 也有）
• Visitor pattern vs. lambda abstractions in Java 8（Kotlin 也有 lambda）
• Visitor Pattern Java 8 Lambda implementation（Kotlin 也有 lambda，记得使用 when 而不是大的 if）

Answer 2

这是一个不进行双重分派但确实实现了数据和作用于它的代码之间的分离的实现。

访问者的调度是使用 when 表达式“手动”完成的（这是详尽的），这需要较少的样板，因为不需要覆盖所有访问者中的 accept() 方法和多个 visit() 方法一个访客。

package visitor.addition
import visitor.addition.Expression.*

interface Visitor {
    fun visit(expression: Expression)
}

sealed class Expression {
    fun accept(visitor: Visitor) = visitor.visit(this)

    class Num(val value: Int) : Expression()
    class Sum(val left: Expression, val right: Expression) : Expression()
    class Mul(val left: Expression, val right: Expression) : Expression()
}

class PrintVisitor() : Visitor {
    val sb = StringBuilder()

    override fun visit(e: Expression) {
        val x = when (e) {
            is Num -> sb.append(e.value)
            is Sum -> stringify("+", e.left, e.right)
            is Mul -> stringify("*", e.left, e.right)
        }
    }

    fun stringify(name : String, left: Expression, right: Expression) {
        sb.append('(')
        left.accept(this); sb.append(name); right.accept(this)
        sb.append(')')
    }

}

fun main(args: Array<String>) {
    val exp = Sum(Mul(Num(9), Num(10)), Sum(Num(1), Num(2)))
    val visitor = PrintVisitor()
    exp.accept(visitor)

    println(visitor.sb) // prints: ((9*10)+(1+2))
}

Answer 3

为了解决这个问题，我会使用这样的东西：

interface Visitable {

    fun accept(visitor: Visitor)
}

然后实现：

class House : Visitable {

    override fun accept(visitor: Visitor) {
         visitor.visit(this)
    }
}

class Car : Visitable {

    override fun accept(visitor: Visitor) {
         visitor.visit(this)
    }
}

访客本身：

interface Visitor {

    fun visit(entity: Car)

    fun visit(entity: House)
}

和实施：

class Printer : Visitor {

    override fun visit(entity: Car) {
         println("Im in A Car")
    }

    override fun visit(entity: House) {
        println( "I'm in a House")
    }
}

用法：

fun main(args: Array<String>) {

    val list = listOf<Visitable>(House(), Car())

    val printer = Printer()

    list.map { it.accept(printer) }
}

输出：

I'm in a House
Im in A Car

Answer 4

可以使用伴随对象和 lambda 的组合来实现动态访问，如下所示：

interface Visitable { fun visit()}

class FooOne(): Visitable {
    val title1 = "111"
    companion object { var visit: (FooOne)->Unit  = {} }
    override fun visit() { FooOne.visit(this) }
}

class FooTwo(): Visitable {
    val title2 = "222"
    companion object { var visit: (FooTwo)->Unit  = {} }
    override fun visit() { FooTwo.visit(this) }
}

/* assign visitor functionality based on types */
fun visitorStars() {
    FooOne.visit = {println("In FooOne: ***${it.title1}***") }
    FooTwo.visit = {println("In FooTwo: ***${it.title2}***") }
}

/* assign different visitor functionality */
fun visitorHashes() {
    FooOne.visit = { println("In FooOne: ###${it.title1}###") }
    FooTwo.visit = {println("In FooTwo: ###${it.title2}###") }
}

fun main(args: Array<String>) {
    val foos = listOf<Visitable>(FooOne(), FooTwo())
    visitorStars()
    foos.forEach {it.visit()}
    visitorHashes()
    foos.forEach {it.visit()}
}

>>>
In FooOne: ***111***
In FooTwo: ***222***
In FooOne: ###111###
In FooTwo: ###222###