Arun Pandian M

Arun Pandian M

Android Dev | Full-Stack & AI Learner

Written by: Arun Pandian M•Published on: Apr 3, 2026

Coproducts — Modeling “Either This or That” in Code

Most bugs don’t come from what your program does. They come from what your program assumes cannot happen.

You think a value will always be present. You assume a request will always succeed. You believe a state will always be valid.

Reality disagrees. A user can be unauthenticated. An API can fail. A screen can be loading.

So the real question is:

That’s where Coproducts come in.

The Core Idea

A coproduct represents a choice:

A + B

Meaning:

A value is either **A OR B** 

Programming Intuition

In Kotlin:

sealed class Result<out T> {
    data class Success<T>(val value: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
}

This means:

Result = Success + Error

At runtime, it’s exactly one of them

Why Not Just Use Null?

val user: User? = null

This tells you that a value is missing, but it does not explain the reason behind it.

Coproducts fix this:

Result.Error("User not found")

Now your system knows what happened

Category Theory View

A coproduct of A and B is an object C with two injections:

i : A → C  
j : B → C

Meaning

  • You can put A into C
  • You can put B into C
  • The Universal Property (Important Insight)

    If you know how to handle:`

    A → X  
    B → X

    Then you automatically know how to handle:

    (A + B) → X
    

    Kotlin Equivalent (Factorizer)

    fun <A, B, C> fold(
        left: (A) -> C,
        right: (B) -> C
    ): (Result<A,B>) -> C = { result ->
        when (result) {
            is Result.Success -> left(result.value)
            is Result.Error -> right(result.error)
        }
    }
    
    sealed class Result<out A,out B> {
     data class Success<A>(val value: A) : Result<A, Nothing>()
        data class Error<B>(val error: B) : Result<Nothing,B>()
    }

    This is the coproduct factorizer

    https://storage.googleapis.com/lambdabricks-cd393.firebasestorage.app/coproduct_factorizer.svg?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Credential=firebase-adminsdk-fbsvc%40lambdabricks-cd393.iam.gserviceaccount.com%2F20261117%2Fauto%2Fstorage%2Fgoog4_request&X-Goog-Date=20261117T194601Z&X-Goog-Expires=3600&X-Goog-SignedHeaders=host&X-Goog-Signature=8ce52b582c568acbdba0df04fa9fe067ef74005df67935974e218632188fbf6f1c50bb3f127b4afbf7fa3de994fba86339494e441fa1b8b07cfe2a437fba83829e01a7dc5c3f044b89f78a2104d4b4e28cac832506bf206a761cde55ac8db9406c5458d401159b09fdcd6b18326994b1ffd4d99c6f96a33b959c54d905ead221b3b198273dfee867db97605946e3021e199a31411e6be8b4115e8773dd2b637dbac60a9108c787c6fa5fc0e358078b13fda77fe37cfc0b1b19caa5ba89d4007d52244f615603318861f6e3463dc6a3c3af263b537b3adadc94dc29de73f3b58bf651fddfcb1c6e5b74057b09de9e98314da20e4eb24f9da2f6f74e7e553d704a

    Real-World Use Case (Android)

    UI State

    When building apps, we often represent UI like this:

    sealed class UiState {
        object Loading : UiState()
        data class Success(val data: String) : UiState()
        data class Error(val message: String) : UiState()
    }

    Why this matters

    A common (but problematic) way to model UI state is:

    var loading = false
    var data: String? = null
    var error: String? = null

    At first glance, this looks simple.

    But it introduces a serious issue:

    • loading = true and data != null can exist together

    • error != null and data != null can exist together

    These are invalid combinations, but nothing prevents them.

    What coproduct gives us

    With: UiState

    You are saying:

    At any moment, the UI is in exactly one state.

    • Loading

    • Success

    • Error

    No invalid combinations are possible.

    This is the essence of a coproduct:

    A value can be one of many possibilities, but only one at a time.

    Composition (Short-Circuiting)

    Coproducts are not just about modeling — they also improve how we write logic.

    Consider this pipeline:

    validate(id) .flatMap(::fetchUser) .flatMap(::mapUi)

    What happens here?

    • If validate fails → everything stops

    • If fetchUser fails → next step is skipped

    • If all succeed → final result is produced

    You don’t write manual checks like:

    if (error != null) return error

    The structure itself ensures:

    Once an error happens, the rest of the pipeline does not run.

    Why this is powerful

    • No nested if conditions

    • No scattered error handling

    • Clear flow of data

    The system enforces correctness for you.

    Final takeaway

    • Product → combine values

    • Coproduct → choose one possibility

    Coproducts let you model real-world situations where something can be in one state at a time — and they ensure your code stays correct by design.
    #typetheory#algebraicdatatypes#buildinpublic#composablesystems#softwaredesign#fpconcepts#eithertype#categorytheory#datamodeling#functionalprogramming#errorhandling#kotlinfp#mathfordevelopers#coproduct#learninpublic
    LAMBDA BRICKS