Pure function And Functional Error Handling

순수함수와 함수형 에러 처리
김규하

왜?!
• RxJava2 지원 종료

왜?!
• RxJava2 지원 종료

• Coroutine 적용에 따른 RxJava 대체제가 필요

순수 함수?
fun pureFunction(value: Any): Result {
// doSomething
return ...
}

순수 함수?
사이드이펙트 X

순수 함수?
사이드이펙트 X

참조투명성 O

순수하지 않은 함수?
val otherValues: MutableMap<String, Any> = mutableMapOf()
fun imPureFunction(): Result {
val value = otherValue[MAP_KEY]
// doSomething
return ...
}

// doSomething
return ...
}
fun imPureFunction(otherValue: MutableMap<String, Any>): Result {
// doSomething
return ...
}

// doSomething
return ...
}
val value = otherValue[MAP_KEY] ?: throw IllegalArgumentException("Error")
// doSomething
return ...
}
// doSomething
return ...
}

val value = otherValue[MAP_KEY] ?: throw IllegalArgumentException("Error")
// doSomething
return ...
}

예외를 던지면 안된다구요?

예외
java.lang.ArrayIndexOutOfBoundsException

예외
android.database.CursorWindowAllocationException

예외
java.lang.StringIndexOutOfBoundsException

예외
javax.net.ssl.SSLHandshakeException
java.lang.NoClassDefFoundError

예외
java.lang.IllegalArgumentException
java.lang.NullPointerException
java.lang.UnsatisﬁedLinkError
java.lang.NoClassDefFoundError
java.lang.OutOfMemoryError
java.net.SocketTimeoutException
javax.net.ssl.SSLHandshakeException

세상에 예외가 이렇게 많은데?

예외
예외가 왜 참조투명성을 해치는지?

예외
fun div(x: Int, y: Int): Int {
return x / y
}
println(div(1, 0))

예외
Exception in thread "main" java.lang.ArithmeticException: /
by zero…

예외
fun div(x: Int, y: Int): Int {
return try {
x / y
} catch (e: Exception) {
e.printStackTrace()
0
}
}
println(div(1, 0))

예외
Exception in thread "main" java.lang.ArithmeticException: /
by zero…

0

1. 예외는 참조 투명성을 해치고 처리를 위한 의존성을 도입한다.
예외

1. 예외는 참조 투명성을 해치고 처리를 위한 의존성을 도입한다.

2. 타입에 안전하지 않다.
예외

함수형 에러 핸들링
• 예외도 보통의 값으로 표현

• 예외도 보통의 값으로 표현

• 예외의 관한 처리를 사용지점 까지 늦춘다.

sealed class FunResult<out T> {
data class Success<out T>(val data: T): FunResult<T>()
data class Failure(val error: Throwable): FunResult<Nothing>()
}

fun div(x: Int, y: Int): FunResult<Int> {
return try {
FunResult.Success(x / y)
FunResult.Error(e)
}
}
println(div(1, 0))
println(div(1, 1))

Error(error=java.lang.ArithmeticException: / by zero)
Success(data=1)

실제 서비스에서는 어떻게

사용할까??

LocalDataSource
DataBase
View
ViewModel
Repository
RemoteDataSource
WebService

ViewModel
Repository
RemoteDataSource
WebService

class MainViewModel(
private val sampleRepository: SampleRepository
) : ViewModel() {
private val _mainItemList = MutableLiveData<List<MainItem>>()
val mainItemList: LiveData<List<MainItem>> get() = _mainItemList
fun getMainItemList() {
viewModelScope.launch(Dispatchers.IO) {
val result = sampleRepository.getRemoteApi()
.map { it.toMainItem() }
launch(Dispatchers.Main) {
_mainItemList.value = result
}
}
}
override fun onCleared() {
super.onCleared()
viewModelScope.cancel()
}
}
ViewModel

class SampleRepository(
private val remoteRemoteDataSource: SampleRemoteDataSource
) {
suspend fun getIOExceptionApi(): List<SampleData> {
val response = remoteRemoteDataSource.getTimeoutExceptionApi()
return response
}
suspend fun getTimeoutExceptionApi(): List<SampleData> {
return response
}
suspend fun getRemoteApi(): List<SampleData> {
return remoteRemoteDataSource.getRemoteApi()
}
}
Repository

class SampleRemoteDataSource(
private val sampleService: SampleService
) {
return try {
sampleService.getTimeOutExceptionRemoteService()
e.printStackTrace()
emptyList()
}
}
return try {
sampleService.getIOExceptionRemoteService()
e.printStackTrace()
emptyList()
}
}
suspend fun getSampleData(): List<SampleData> {
return sampleService.getSampleData()
}
}
RemoteDataSource

WebService
class SampleServiceImpl : SampleService {
override suspend fun getSampleData(): List<SampleData> =
coroutineScope {
delay(2000)
resultDataFromBackend
}
override suspend fun getTimeOutExceptionRemoteService(): List<SampleData> =
coroutineScope {
delay(5000)
throw TimeoutException("invalid data")
}
override suspend fun getIOExceptionRemoteService(): List<SampleData> =
coroutineScope {
delay(5000)
throw IOException("invalid data")
}
}

) {
return try {
e.printStackTrace()
emptyList()
}
}
return try {
e.printStackTrace()
emptyList()
}

) {
return try {
e.printStackTrace()
e
}
}
return try {
e.printStackTrace()
emptyList()
}

) {
return try {
e.printStackTrace()
e
}
}
return try {
e.printStackTrace()
emptyList()
}
Error!

) {
suspend fun getTimeoutExceptionApi(): Any {
return try {
e.printStackTrace()
e
}
}
return try {
e.printStackTrace()
emptyList()
}

) {
return try {
e.printStackTrace()
e
}
}
suspend fun getIOExceptionApi(): List<SampleDataAtData> {
return try {
e.printStackTrace()
emptyList()
}
}
suspend fun getSampleData(): List<SampleDataAtData> {
}
}
RemoteDataSource

return try {
e.printStackTrace()
emptyList()
}
}
}
}

}
return try {
e.printStackTrace()
emptyList()
}
}
return try {
sampleService.getSampleData()
e.printStackTrace()
emptyList()
}
}
}

}
return try {
e.printStackTrace()
emptyList()
}
}
return try {
e.printStackTrace()
e
}
}
}

}
return try {
e.printStackTrace()
emptyList()
}
}
return try {
e.printStackTrace()
e
}
}
}
Error!

}
return try {
e.printStackTrace()
emptyList()
}
}
suspend fun getSampleData(): Any {
return try {
e.printStackTrace()
e
}
}
}

) {
return response
}
return response
}
return remoteRemoteDataSource.getSampleData()
}
}
Repository

return response
}
return response
}
}
}

return response
}
return response
}
}
}
Is Any type

return response
}
return response
}
return remoteRemoteDataSource.getSampleData() as List<SampleData>
}
}

return response
}
return response
}
}
}

) : ViewModel() {
val result = sampleRepository.getSampleData()
}
}
}
super.onCleared()
}
}
ViewModel

) : ViewModel() {
}
}
}
super.onCleared()
}

lass MainViewModel(
: ViewModel() {
}
}
}
super.onCleared()
Is Any type List<SampleData>Or

lass MainViewModel(
: ViewModel() {
}
}
}
super.onCleared()
Is Any type

lass MainViewModel(
: ViewModel() {
.map { it.toMainItem() } // Compile Error
}
}
}
super.onCleared()

lass MainViewModel(
: ViewModel() {
}
}
}
super.onCleared()
List<SampleData>

lass MainViewModel(
: ViewModel() {
.map { it.toMainItem() } // do it or throw
}
}
}
super.onCleared()

data class Success<out T>(val data: T): FunResult<T>()
data class Failure(val error: Throwable): FunResult<Nothing>()
}

data class Success<out T>(val data: T) : FunResult<T>()
data class Error(val error: Throwable) : FunResult<Nothing>()
companion object {
suspend fun <T> safeCall(f: suspend () -> T): FunResult<T> = try {
Success(f.invoke())
Error(e)
}
}
}
suspend fun <T, R> FunResult<T>.map(f: suspend (T) -> R): FunResult<R> = when (this) {
is FunResult.Success<T> -> FunResult.Success(f.invoke(data))
is FunResult.Error -> this
}
suspend fun <T, R> FunResult<T>.flatMap(f: suspend (T) -> FunResult<R>): FunResult<R> = when (this) {
is FunResult.Success -> f.invoke(data)
is FunResult.Error -> this
}
suspend fun <T> FunResult<T>.fold(success: suspend (T) -> Unit, failure: (Throwable) -> Unit) = when (this) {
is FunResult.Success -> success.invoke(data)
is FunResult.Error -> failure.invoke(error)
}

) {
return try {
e.printStackTrace()
e
}
}
return try {
e.printStackTrace()
emptyList()
}
}
return try {
e.printStackTrace()
e
}
}
}
RemoteDataSource

) {
return try {
e.printStackTrace()
e
}
}
return try {

) {
suspend fun getTimeoutExceptionApi(): FunResult<List<SampleData>> {
return FunResult.safeCall {
}
}
return try {
e.printStackTrace()
private val sampleService:
SampleService
) {
suspend fun
getTimeoutExceptionApi(): Any
{
return try {
sampleService.getTimeOutExcept
ionRemoteService()
} catch (e: Exception)

suspend fun <T> safeCall(f: suspend () -> T): FunResult<T> = try {
Success(f.invoke())
Error(e)
}
) {
}
}
return try {
e.printStackTrace()
SampleService
) {
suspend fun
getTimeoutExceptionApi(): Any
{
return try {
ionRemoteService()
} catch (e: Exception)

) {
}
}
return try {
e.printStackTrace()
emptyList()
}
}
return try {
e.printStackTrace()
e
}
}
}
RemoteDataSource

return try {
e.printStackTrace()
emptyList()
}
}
return try {
e.printStackTrace()
e
}
}
}

return try {
e.printStackTrace()
emptyList()
}
}
suspend fun getRemoteApi(): FunResult<List<SampleDataAtData>> {
}
}
}
SampleService
) {
suspend fun
getTimeoutExceptionApi():
FunResult<List<SampleData>> {
return
FunResult.safeCall {
ionRemoteService()

) {
private val sampleDataAtDomainCache: HashMap<String, List<SampleData>> = hashMapOf()
suspend fun getIOExceptionApi(): FunResult<List<SampleData>> {
if (response is FunResult.Success) {
// do memory cache
}
return response
}
// do memory cache
}
return response
}
suspend fun getSampleData(): FunResult<List<SampleData>> {
val response = remoteRemoteDataSource.getSampleData()
// do memory cache
}
return response
}
}
private val
remoteRemoteDataSource:
SampleRemoteDataSource
) {
suspend fun
getIOExceptionApi():
List<SampleData> {

) : ViewModel() {
}
}
}
super.onCleared()
}
}
) : ViewModel() {
private val _error = MutableLiveData<Throwable>()
val error: LiveData<Throwable> get() = _error
.map { it.map { it.toMainItem() } }
result.fold(
success = {
_mainItemList.value = it
}
},
failure = {
withContext(Dispatchers.Main) {
_error.value = it
}
}
)
}
}
super.onCleared()
}
}

private val _error = MutableLiveData<Throwable>()
val error: LiveData<Throwable> get() = _error
.map { it.map { it.toMainItem() } }
result.fold(
success = {
_mainItemList.value = it
}
},
failure = {
withContext(Dispatchers.Main) {
_error.value = it
}
}
)
}
}

결론
• 순수함수 작성이 쉬워졌다.

결론

• 예외도 하나의 값으로 실제 값을 사용할 때 처리 하므로 다른 함수
에서 신경쓸 필요가 없다.

결론

• 예외도 하나의 값으로 실제 값을 사용할 때 처리 하므로 다른 함수
에서 신경쓸 필요가 없다.

• 같은 데이터를 가져오는 레포지토리를 레고 블록 처럼 재사용 할
수 있다.

Pure function And Functional Error Handling

More Related Content

What's hot

Recently uploaded

Pure function And Functional Error Handling