A modern programming language that makes developers happier.

kotlinlang

Would you go to `sealed class Operation(val value: Int) { class Add()...class Divide()}` or `class Operation(val type:Type, val value: Int)` where `Type` is enum?

I'd always go in the direction of more detailed compiler checks (as long as it makes sense). So I'd use sealed classes here.

If there is a sealed class and I want to use `when` with an object of this class, I need to check for all the subtypes or the code won't compile. It's really cool when I add a new type.

sealed classes act as a enum in a when expression but can hold data unlike enums

exactly what Marco said - when expression works same for enum and sealed classes

Yes, but you asked about using `sealed class` vs `class`. So in this case I'd use the sealed version. There was no enum in your question :slightly_smiling_face:

it depends on scenario, if all operations work with same value type, enums can work as well

otherwise, sealed classes are more flexible

I see. I think in the general case I cannot see any advantage of one over another.

oke, my coworker wrote next ```data class AppErrorNetwork(
        override val cause: Throwable
) : AppError()

data class AppErrorBackendRequest(
        override val cause: Throwable
) : AppError()

data class AppErrorUnknown(
        override val cause: Throwable,
        val message: String
) : AppError()
```

and sealed classes can form hierarchies, like: ```internal sealed class ProxyState {
    object NoProxy : ProxyState()
    sealed class Proxy(val info: ProxyInfo) : ProxyState() {
        class Initializing(info: ProxyInfo) : Proxy(info)
        class Active(info: ProxyInfo) : Proxy(info)
    }
}```

for me the class is used as marker, I probably long time Java developer and user to have enum instead for marking type

understood, give sealed classes a try, they are improvement over enum, same as `when` is over `switch`

Your errors look modeled better as sealed classes as data isn't identical for each option

BTW I work with kotlin over two years now, but this topic is always coming back

I like sealed classes, I do find them useful to express various options

For example, that code I posted was an enum yesterday but was "upgraded" to sealed classes today

did you have proxy info null with enum type? sure it is not nice

yeah, I had few components that were not null only with Proxy so I wrapped them in ProxyInfo and voala, no null checks everywhere

it's really flexible, I might have to add more data to Active or Initialized state and with sealed classes it will be no issue at all

or I could split Active into two states with different data

and my `when` expressions are super simple, compiler makes sure I covered all cases

all the benefits of enum without the restrictions