Kotlin and discriminated unions (sum types)

Question

Does Kotlin have anything like discriminated unions (sum types)? What would be the idiomatic Kotlin translation of this (F#):

type OrderMessage =
    | New of Id         


        

Answer 1

The sealed class in Kotlin has been designed to be able to represent sum types, as it happens with the sealed trait in Scala.

Example:

sealed class OrderStatus {
    object Approved: OrderStatus()
    class Rejected(val reason: String): OrderStatus()
}

The key benefit of using sealed classes comes into play when you use them in a when expression for the match.

If it's possible to verify that the statement covers all cases, you don't need to add an else clause to the statement.

private fun getOrderNotification(orderStatus:OrderStatus): String{
    return when(orderStatus) {
        is OrderStatus.Approved -> "The order has been approved"
        is OrderStatus.Rejected -> "The order has been rejected. Reason:" + orderStatus.reason
   }
}

There are several things to keep in mind:

• In Kotlin when performing smartcast, which means that in this example it is not necessary to perform the conversion from OrderStatus to OrderStatus.Rejected to access the reason property.

• If we had not defined what to do for the rejected case, the compilation would fail and in the IDE a warning like this appears:

'when' expression must be exhaustive, add necessary 'is Rejected' branch or 'else' branch instead.

• when it can be used as an expression or as a statement. If it is used as an expression, the value of the satisfied branch becomes the value of the general expression. If used as a statement, the values of the individual branches are ignored. This means that the compilation error in case of missing a branch only occurs when it is used as an expression, using the result.

This is a link to my blog (spanish), where I have a more complete article about ADT with kotlin examples: http://xurxodev.com/tipos-de-datos-algebraicos/