Back to Visitor/Sealed classes w/extensions. If you have a good reason to separate the operation from the object hierarchy, Both of these patterns require a stable object hierarchy, because using this pattern makes it easy to add operations while making it painful to add new elements. For some excellent docs on how and when to use Visitor, see here. For the alternate version using sealed classes and extension methods, I will provide a quick example.

sealed class Animal(val name: String)
class LandAnimal(name: String, val legs: Int) : Animal(name)
class SeaAnimal(name: String, val flippers: Int) : Animal(name)
class OtherAnimal(name: String) : Animal(name)

fun Animal.printAppendages() {
    when (this) {
        is LandAnimal -> printAppendages()
        is SeaAnimal -> printAppendages()
        is OtherAnimal -> printAppendages()
    }
}

fun SeaAnimal.printAppendages() {
    print(" has $flippers flippers")
}

fun LandAnimal.printAppendages() {
    print(" has $legs legs")
}

fun OtherAnimal.printAppendages() {
    print(" has no appendages")
}

fun main() {
    val lassie = LandAnimal("Lassie", 4)
    val nemo = SeaAnimal("Nemo", 2)

    lassie.printAppendages()
    nemo.printAppendages()
}

I think in many cases the sealed class and extension method pattern accomplishes Visitor pattern, without some of the weirdness. You still accomplish the goal, separating the operation from the object hierarchy. And because the objects are marked sealed, its marked in code that “this object structure is hard to change, and should remain stable”

For reference, the traditional Visitor pattern option:

open class Animal(val name: String) {
    open fun accept(visitor: AnimalVisitor) {
        visitor.visit(this)
    }
}
class LandAnimal(name: String, val legs: Int) : Animal(name) {
    override fun accept(visitor: AnimalVisitor) {
        visitor.visit(this)
    }
}
class SeaAnimal(name: String, val flippers: Int) : Animal(name) {
    override fun accept(visitor: AnimalVisitor) {
        visitor.visit(this)
    }
}

interface AnimalVisitor {
    fun visit(animal: Animal)
    fun visit(landAnimal: LandAnimal)
    fun visit(seaAnimal: SeaAnimal)
}

class PrintAppendages : AnimalVisitor {
    override fun visit(animal: Animal) {
        print(" has no appendages")
    }

    override fun visit(landAnimal: LandAnimal) {
        print(" has ${landAnimal.legs} legs")
    }

    override fun visit(seaAnimal: SeaAnimal) {
        print(" has ${seaAnimal.flippers} flippers")
    }

}

fun main() {
    val lassie = LandAnimal("Lassie", 4)
    val nemo = SeaAnimal("Nemo", 2)

    PrintAppendages().visit(lassie)
    PrintAppendages().visit(nemo)
}