Kotlin Sealed Interfaces: Modeling Complex Domain State Without Compromise

// One dimension: a sealed class is enough
sealed class NetworkResult<out T> {
    data class Success<T>(val data: T) : NetworkResult<T>()
    data class Error(val code: Int, val message: String) : NetworkResult<Nothing>()
    data object Loading : NetworkResult<Nothing>()
}

// Several dimensions: one sealed interface per trait
sealed interface ScreenState

sealed interface Refreshable {
    val isRefreshing: Boolean
}

sealed interface Paginated {
    val currentPage: Int
    val hasNextPage: Boolean
}

data object Loading : ScreenState

data class Failed(val message: String) : ScreenState

// A single type implements all three. A class could not do this
// by extending three sealed classes.
data class ProductList(
    val products: List<Product>,
    override val isRefreshing: Boolean = false,
    override val currentPage: Int = 1,
    override val hasNextPage: Boolean = false,
) : ScreenState, Refreshable, Paginated

// An enum can implement a sealed interface too
sealed interface SortOrder
enum class ProductSort : SortOrder { RELEVANCE, PRICE, NEWEST }

sealed interface ContentState {
    data object Empty : ContentState
    data class Populated(val items: List<Product>) : ContentState
    data class Error(val message: String) : ContentState
}

sealed interface SyncState {
    data object Synced : SyncState
    data object Syncing : SyncState
    data class Conflict(val localVersion: Int, val remoteVersion: Int) : SyncState
}

sealed interface ConnectivityState {
    data object Online : ConnectivityState
    data object Offline : ConnectivityState
    data object Metered : ConnectivityState
}

data class ProductScreenState(
    val content: ContentState,
    val sync: SyncState,
    val connectivity: ConnectivityState,
)

// when as an EXPRESSION: every case must be covered, no else
fun ConnectivityState.bannerText(): String? = when (this) {
    ConnectivityState.Online -> null
    ConnectivityState.Offline -> "You are offline"
    ConnectivityState.Metered -> "Using mobile data"
}

fun SyncState.label(): String = when (this) {
    SyncState.Synced -> "Up to date"
    SyncState.Syncing -> "Syncing"
    is SyncState.Conflict -> "Conflict: local v$localVersion, remote v$remoteVersion"
}

@Composable
fun ProductScreen(state: ProductScreenState) {
    state.connectivity.bannerText()?.let { Banner(it) }
    SyncLabel(state.sync.label())
}

sealed interface PaymentMethod {
    val displayName: String
}

sealed interface CardPayment : PaymentMethod {
    val last4: String
    val expiryMonth: Int
    val expiryYear: Int
}

sealed interface BankPayment : PaymentMethod {
    val routingNumber: String
    val accountLast4: String
}

data class Visa(
    override val last4: String,
    override val expiryMonth: Int,
    override val expiryYear: Int,
) : CardPayment {
    override val displayName = "Visa ****$last4"
}

data class AchTransfer(
    override val routingNumber: String,
    override val accountLast4: String,
) : BankPayment {
    override val displayName = "Bank ****$accountLast4"
}

// A BankPayment cannot be passed here. The mistake does not compile.
fun processCardPayment(card: CardPayment): PaymentResult =
    gateway.chargeCard(card)

fun processBankPayment(bank: BankPayment): PaymentResult =
    gateway.debitAccount(bank)

// And the top-level dispatch is still exhaustive
fun process(method: PaymentMethod): PaymentResult = when (method) {
    is CardPayment -> processCardPayment(method)
    is BankPayment -> processBankPayment(method)
}

sealed interface UiEvent

sealed interface Trackable : UiEvent {
    val eventName: String
}

sealed interface Undoable : UiEvent {
    fun undo(): UiEvent
}

sealed interface RequiresAuth : UiEvent

// One event, three traits
data class AddToCart(
    val productId: String,
    val quantity: Int,
) : Trackable, Undoable, RequiresAuth {
    override val eventName = "add_to_cart"
    override fun undo() = RemoveFromCart(productId, quantity)
}

data class RemoveFromCart(
    val productId: String,
    val quantity: Int,
) : Trackable, Undoable {
    override val eventName = "remove_from_cart"
    override fun undo() = AddToCart(productId, quantity)
}

// The trait checks live in exactly one place
class EventProcessor(
    private val analytics: Analytics,
    private val undoManager: UndoManager,
    private val authGuard: AuthGuard,
) {
    suspend fun process(event: UiEvent) {
        if (event is RequiresAuth) authGuard.ensureAuthenticated()
        if (event is Trackable) analytics.track(event.eventName)
        if (event is Undoable) undoManager.push(event)
    }
}