LiveData

pure

MutableLiveData(…)

Transformations.map(myLiveData, myTransformation)

map

Transformations.switchMap(myLiveData, myTransformationFn)

flatMap

IO

IO.unsafeRunAsync

SomeLiveData.observe(…)

EitherT<ForIO, E, A>

parMapN

IO.effect(IO.dispatchers().io() + MDCContext())

IO.effect(MDCContext())

IO.dispatchers().io()

0.11.0-SNAPSHOT

EitherT

IO<E, A>

IO<E, A>

A

A

A

{ "b": { ... } }

0.10.4

EitherT

b

{ ... }

fun getLeads(): IO<Exception, List<Lead>> =
        IO.fx<Exception, List<Lead>> {
            transaction {
                Leads.selectAll().map { toLead(it) }
            }
        }

val response = getLeads().attempt().map {
                when (it) {
                    is Either.Left -> mapOf("error" to it.a.message)
                    is Either.Right -> present(it.b)
                }
            }
            call.respond(response.suspended())

attempt

{
  "b": [
    {
      "id": 2,
      "firstName": "Matt",
      "lastName": "Moore"
    }
  ]
}

EitherT

fun getLeads(): EitherT<ForIO, Exception, List<Lead>> = EitherT(
        IO {
            Right(
                    transaction {
                        Leads.selectAll().map { toLead(it) }
                    }
            )
        }.handleError { Left(Exception(it.message)) }
)

val response = getLeads().value().fix().map {
    when (it) {
        is Either.Left -> mapOf("error" to it.a.message)
        is Either.Right -> present(it.b)
    }
}.suspended()
call.respond(response)

EitherT

[
  {
    "id": 2,
    "firstName": "Matt",
    "lastName": "Moore"
  }
]

b

with (Option.monadError()) {
  createId("123") shouldBe Some(123)
  // ...

createId

MonadThrow

MonadError

monadThrow

Option

fun prepareAndSendMultiple(listMessages: List<Message>, connectionStringKey: String, queueKey: String): IO<Unit> =
         listMessages.parTraverse { message ->
            prepareAndSend(message, connectionStringKey, queueKey) // returns IO<Unit>
        }.unit()

IO

fold

class GetStoriesListUseCase @Inject constructor(
    private val hackerNewsService: HackerNewsService
) {

    suspend fun topStories(
        pageNumber: Int,
        pageSize: Int = 100
    ): Either<Throwable, List<StoryUIModel>> =
        readTopStoriesIds(pageSize)
            .flatMap { getTopStoriesDetails(it) }
            .suspended()

    private fun getTopStoriesDetails(topStoriesIds: List<Id<Long>>): IO<Throwable, List<StoryUIModel>> =
        topStoriesIds.map { it.value() }.parTraverse { anId ->
            IO.effect(<http://Dispatchers.IO|Dispatchers.IO>) {
                Timber.d("${Thread.currentThread().name}")
                hackerNewsService.topStoryDetail(anId).toStoryUIModel()
            }
        }

    private fun readTopStoriesIds(pageSize: Int): IO<Throwable, List<Id<Long>>> =
        IO.effect {
            hackerNewsService.topStoriesIds().map { Id.just(it) }.take(pageSize)
        }

    private fun StoryDetails.toStoryUIModel() =
        StoryUIModel(id = id, title = title, author = by, url = url)
}

body

StateT<ForIO, X, Y>

.runM(IO.monad(), currentState)

IO

private var

Id

State<MyState, Unit>

(newState, _)

myState = newState

StateT<ForIO, MyState, Unit>

IO

.unsafeRunAsync { … state = newState }

StateT<ForIO, MyState, SomePartialStateChange>

MyState

ReaderT<ForIO, MyState, SomePartialStateChange>

StateT

IO

.effect

IO

CompletableFuture

IO.parMapN

IO.parMapN(IOThread, someIO, anotherIO) { a, b ->
  continueOn(MainThread)
  // do stuff
}

continueOn

parMapN

IO.parMapN(…).continueOn(MainThread)

ReaderT { 
  ... IO.parMapN(IOThread, ...).continueOn(MainThread)
}.run(context).fix().unsafeRunAsync {
  it.fold({}, { myLiveData.value = it })
}

setValue

continueOn

OptionT.fx {
  val x: Foo = OptionT(getFoo()).bind()
  val y: Bar = OptionT(getBar()).bind()
}.value().fix().unsafeRunAsync {}

val y = …

Foo

Bar

getFoo(): IO<Option<Foo>>

getBar(): IO<Option<Bar>>

getFoo

getBar

Foo?

IO<Option<Foo/Bar>>

FilterIndex

val lens = MyClass.listProperty
              .every(ListFilterForIndex { index -> index % 2 })
              .itemProperty
var myObject = MyClass()
myObject = lens.modify(myObject) { "modified string" }

List.map

Option.map