Is there a way to use Sealed Interfaces / Classes in such a way that you can have a base sealed interface that other Sealed Interfaces / Classes can extend to get shared values?

interface UserRepository {

    sealed interface UserRepositoryResult {
        object UserNotFound : UserRepositoryResult
        object InvalidId : UserRepositoryResult
    }

    sealed interface FindUserByIdResult : UserRepositoryResult {
        class Success(val user: User) : FindUserByIdResult
    }

    fun findUserById(id: User.Id): FindUserByIdResult

    sealed interface DeleteUserByIdResult : UserRepositoryResult {
        object Success : DeleteUserByIdResult
    }

    fun deleteUserById(id: User.Id): DeleteUserByIdResult

The above compiles, but when adding a

when

around the result of

findUserById

, it only looks for the

Success

branch

when (this@UserRepository.findUserById(0)) {
        is UserRepository.FindUserByIdResult.Success -> TODO()
    }

it's only expecting the one branch nesting it doesn't make a difference either

sealed interface UserRepositoryResult {
        object UserNotFound : UserRepositoryResult
        object InvalidId : UserRepositoryResult
        
        sealed interface FindUserByIdResult : UserRepositoryResult {
            class Success(val user: User) : FindUserByIdResult
        }
        sealed interface DeleteUserByIdResult : UserRepositoryResult {
            object Success : DeleteUserByIdResult
        }
    }

  
    fun findUserById(id: User.Id): UserRepositoryResult.FindUserByIdResult
    fun deleteUserById(id: User.Id): UserRepositoryResult.DeleteUserByIdResult

is there a way around this other than copying and pasting UserNotFound and InvalidId into both sealed interfaces?

I would probably do it with a generic:

sealed interface UserRepositoryResult<out T> {
    object UserNotFound : UserRepositoryResult<Nothing>
    object InvalidId : UserRepositoryResult<Nothing>
    data class Success<T>(val data: T): UserRepositoryResult<T>

    fun findUserById(id: User.Id): UserRepositoryResult<User>
    fun deleteUserById(id: User.Id): UserRepositoryResult<Unit>
}

that would work for this one specific case, but if if

fun dosSomethingElseById(id: User.Id): DoSomethingElseByIdResult

has more possible errors, then that error should be inside

DoSomethingElseByIdResult

including the

InvalidId

and

UserNotFound

errors Sounds like a limitation of sealed interfaces / classes

Then maybe something like this may help you, instead of defining

UserNotFound

and

InvalidId

everywhere, you define them in a separate sealed interface, which extends the concrete result interfaces:

sealed interface UserRepositoryResult {
    sealed interface GenericErrorResult: FindUserByIdResult, DeleteUserByIdResult{
        object UserNotFound : GenericErrorResult
        object InvalidId : GenericErrorResult        
    }
        
    sealed interface FindUserByIdResult : UserRepositoryResult {
        class Success(val user: User) : FindUserByIdResult
    }
    sealed interface DeleteUserByIdResult : UserRepositoryResult {
        object Success : DeleteUserByIdResult
    }
}

fun findUserById(id: User.Id): UserRepositoryResult.FindUserByIdResult
fun deleteUserById(id: User.Id): UserRepositoryResult.DeleteUserByIdResult

that's an interesting way of solving it!! instead of extending a generic interface, let the generic interface extend the specific interface. Thanks a lot!!