val callWithTimeout: IO<Model> = IO.raceN(
            IO.effect { service.getModel() },
            IO.sleep(2.seconds)
        )

fx

continueOn

<http://dispatchers.io|dispatchers.io>()

<http://Dispatchers.IO|Dispatchers.IO>

IO.fx {
            effect { _viewState.postValue(ViewState.Loading) }.bind()
            continueOn(dispatchers().io()) // dispatchers from IO
            val repositoryDto: RepositoryDto = effect { service.getRepository() }.bind()
            continueOn(Dispatchers.Default) // Dispatchers from Coroutines
            ViewState.Content(repositoryDto)
        }

val backgroundTask = IO.fx {
            effect { Timber.d("starting sleep...") }.bind()
            sleep(10.seconds).bind()
            effect { Timber.d("sleep ended...") }.bind()
            raiseError<Unit>(Throwable("Bang!!")).bind()
        }

        IO.fx {
            effect { _viewState.postValue(ViewState.Loading) }.bind()
            continueOn(Dispatchers.Default)
            backgroundTask.fork().bind()
            ViewState.Content(GithubService.model) // show static data
        }
            .handleError { ViewState.Error(it.errorMessage()) }
            .flatMap { IO.effect { _viewState.postValue(it) } }
            .unsafeRunScoped(viewModelScope) { }

ViewModel

backgroundTask

fun <T, E> IO<T>.setState(handleError: (Throwable) -> E, onSuccess: (T) -> IO<Any>) = IO.fx {
        val state = !this@setState.attempt()
        state.fold(
            { handleError(it) },
            {
                // Other stuff happening…
                !onSuccess(it)
            }
        )
    }

    @Test
    fun test() {
        val handleError = { t: Throwable -> println("Error: ${t.message}") }
        val onSuccess = { bool: Boolean ->
            IO.fx {
                println("Starting")
                !effect { delay(5000) } // --> SwitchMapping should happen around here
                println("Finished with value $bool")
            }
        }
        // Here, this is what I don't know how to "Observablify" to send multiple events
        IO.just(true).setState(handleError, onSuccess).unsafeRunAsync {}
        IO.just(false).setState(handleError, onSuccess).unsafeRunSync()
    }

Starting
Starting
Finished with value false // The other one should be "switchMapped"

ListK<MapK<String,ListK<String>>>

Cannot access Arrow.Kind which is a supertype of arrow.core.Either.Right

Either (found in arrow.core)

suspend fun parse(str: String): Either<String, Int> =
    Either.catch { str.toInt() }.mapLeft { "wrong string value" }

IO.unsafeRunSync

* **NOTE** this function is intended for testing, it should never appear in your mainline production code!

Try {
  //db call here
}.toEither {
  //handle db errors
}

Kind<F, A>

Kind<G, A>

Kind<G, B>

Restricted suspending functions can only invoke member or extension suspending functions on their restricted coroutine scope

Option.fx {}

Option.fx {}

<ERROR CLASS>

tailrec fun <L, A, B> tailRecM(a: A, f: (A) -> Kind<<ERROR CLASS><L>, Either<A, B>>): Either<L, B>

Union

fun NonFatal(t: Throwable): Boolean =
  when (t) {
    is VirtualMachineError, is ThreadDeath, is InterruptedException, is LinkageError -> false
    else -> true
  }

UserServiceAlgerbra

suspend

IO

raiseError

suspend fun createUser(user: User): Unit

Comparator

with

ej : data class PersonalDataModel(
    val firstName: Option<String>
)

firstName.modify(state){ //here i have a String instead of Option<String> }

fun doWorkWithIO() {
        val time = measureTime {
            IO.fx {
                val effects = mutableListOf<Kind<ForIO, Int>>()
                for (i in 0..1_000_000) {
                    val thing = effect { i }
                    effects.add(thing)
                }
                effects.forEach { it.bind() }
            }.unsafeRunSync()
        }
        println("Default IO took $time")
    }

    fun doWorkWithFork() {
        val time = measureTime {
            IO.fx {
                val effects = mutableListOf<Fiber<ForIO, Int>>()
                for (i in 0..1_000_000) {
                    val thing = effect { i }.fork().bind()
                    effects.add(thing)
                }
                effects.forEach { it.join() }
            }.unsafeRunSync()
        }
        println("Fibers took $time")
    }

doWorkWithIO

doWorkWithFork