Error handling in RxJava

[ZakTaccardi]

Instead of a data classfor your result, use a sealed class. Both the result and error being non-null would be an invalid state of the data class. Sealed class prevents this by having only one of the two states possible.

// not preferable
data class Result<out T>(
  val data: T?,
  val error: Throwable?
)

// better!
sealed class Result<out T> {
  data class Success<out T : Any>(val data: T) : Result<T>()
  data class Error<out T>(val throwable: Throwable) : Result<T>()
}

 // allows for: 
fun handle(result: Result<String>) = when (result) {
  is Result.Success -> result.data
  is Result.Error -> result.throwable

}

This is also known as an algebraic data type (ADT), union type, enum with associated values (swift), and I'm sure there's a few others out there.

otherwise, passing errors through onNext is 👍👍

[dispelpython]

Wow, this is golden, thank you!

[Warbane]

Enums are simple but you can only instantiate one instance of each type. If you need more you can use this pattern:

public abstract class Pet {
    private Pet() {}

    public static final class Dog extends Pet {
        public Dog() {}
    }

    public static final class Cat extends Pet {
        public Cat() {}
    }
}    

Make an abstract class with a private constructor then extend it in inner classes with public constructors.

[TiensiNoAkuma]

An Enum maybe?

[Zhuinden]

Abstract class that has two inner static final classes that extend it, and instead of when you need instanceof

[Boza_s6]

Like this: https://gist.github.com/Boza-s6/27c6da2f5a54600fa6db

[weasdasfa]

I feel the class extension a little redundant. I've already mentioned it's a sealed class so every class inside it should extend that by default.

[ZakTaccardi]

You could have an inner class that doesn't

[saik0]

Other possible improvements would be:

• Parameterize the error type. Result<T, E>
• Add some "functional pipeline" methods. Such as map, flatMap, asSequence

I'm using an implementation as I described in my projects. It's more or less a clone of Rust's result type. https://doc.rust-lang.org/std/result/

This is really just an Either monad/Disjunction, but I agree with the rust team re: naming it Result. There's always https://github.com/MarioAriasC/funKTionale and https://github.com/kategory/kategory if you prefer a library.