La plantilla de visitante está en desuso para Kotlin, pero vale la pena saber

Considere el patrón de diseño Visitor y demuestre que no debe usarlo cuando programe en Kotlin. Habrá una teoría, una implementación minimalista, la implementación de un reemplazo y los argumentos a favor de un reemplazo, respaldados por investigaciones prácticas. No habrá diagramas de clase. Puedes probar todo en línea en play.kotlinlang.org

En mi extremo , JSON . Finite State Machine, Visitor. State Machine , Visitor, — "!". , , . — , , . — , . — .

Visitor. . , LinkedIn , , . Visitor , ( ). Hollywood Agent — " — ". - . , . Python JavaScript . "", — — , . Java .

, , ( ) . , , ( ), . — . Kotlin " " , ( , ).

— Visitor . Visitor , , . , , , , . , , , , . Visitor.

, : . sealed class , .
: .

fun main() {
    Guest().visit( Human(""))
    Guest().visit( Cat(""))
}

sealed class LivingCreature
class Human(val name: String): LivingCreature()
class Cat(val colour: String): LivingCreature()

interface Visitor {
    fun visit(creature : Human)
    fun visit(creature : Cat)
}
class Guest: Visitor {
    override fun visit(human: Human) = println("  ${human.name}")
    override fun visit(pet: Cat) = println("  (  ${pet.colour})")
}

— . , visit . , Human Cat LivingCreature. :

fun main() {
    val human: LivingCreature = Human("")
    val cat  : LivingCreature = Cat("")
    Guest().visit( human) 
    Guest().visit( cat )
}

sealed class LivingCreature
class Human(val name: String): LivingCreature()
class Cat(val colour: String): LivingCreature()

interface Visitor {
    fun visit(creature : Human)
    fun visit(creature : Cat)
}
class Guest: Visitor {
    override fun visit(human: Human) = println("  ${human.name}")
    override fun visit(pet: Cat) = println("  (  ${pet.colour})")
}

, visit(LivingCreature). , , — , , . , , .

Visitor. , , — Human Cat, , Guest (Visitor) . LivingCreature Visitor visit, .

fun main() {
    val human: LivingCreature = Human("")
    val cat  : LivingCreature = Cat("")
    human.accept( Guest() ) //   LivingCreature.accept( Visitor ),         
    cat.accept( Guest() ) // 
}

sealed class LivingCreature {
    abstract fun accept(visitor: Visitor) //    inline fun -     
}
interface Visitor {
    fun visit(creature : Human)
    fun visit(creature : Cat)
}
class Human(val name: String): LivingCreature() {
    override fun accept(visitor: Visitor) = visitor.visit(this) //    Human,    visit(Human)  -
}
class Cat(val colour: String): LivingCreature(){
    override fun accept(visitor: Visitor) = visitor.visit(this) //    Cat,    visit(Cat)  -
}

class Guest : Visitor{
    override fun visit(creature : Human) = println("  ${creature.name}")
    override fun visit(creature : Cat) = println("  (  ${creature.colour})")
}

— inline fun , - .
— visit , — ( ) . accept, — . Visitor.

— . . — accept. , . , — . Visitor.

, Visitor — , - .

" "?

LivingCreature Visitor.visit(LivingCreature)?

fun main() {
    val human: LivingCreature = Human("")
    val cat  : LivingCreature = Cat("")
    Guest().visit(human )
    Guest().visit( cat )
}

sealed class LivingCreature 
interface Visitor {
    fun visit(creature: LivingCreature)
}
class Human(val name: String): LivingCreature()
class Cat(val colour: String): LivingCreature()

class Guest : Visitor{
    override fun visit(creature : LivingCreature) = when(creature) {
        is Human -> println( "  ${creature.name}")
        is Cat -> println( "  (  ${creature.colour} ) ")
    }
}

, , . . ? , Java instanceof , , , JVM — Java. - — ++. "" . - , instanceof , JVM. , JVM .

Resulta que puedes escribir pruebas de rendimiento de Kotlin y Java en JHM , lo cual hice. El resultado me sorprendió: la versión con Visitor funciona muchas veces más lenta que la versión con when / smart cast . Puedes verlo aquí:
mi repositorio en GitHub

recomendaciones

• El visitante es un gran ejercicio para la mente y recomiendo probarlo en situaciones inesperadas, pero fuera de interés académico.
• Visitor mejora el código visual de Java y le permite expresar el comportamiento más claramente. Una buena opción para generadores, patrones de controlador de eventos (ver ANTLR).
• El visitante pierde la legibilidad y el rendimiento de la solución "ingenua" en Kotlin debido a las peculiaridades del lenguaje.