Is there a way to use Sealed Interfaces / Classes ...

# getting-started

[janvladimirmostert]

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 ([e-mail](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?

[Edwar D Day]

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>
}

[janvladimirmostert]

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

[Edwar D Day]

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

[janvladimirmostert]

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!!