boolean

Either

continueOn(NonCancellable)

import <http://arrow.fx.IO|arrow.fx.IO>
import arrow.fx.extensions.fx
import kotlinx.coroutines.NonCancellable
import kotlinx.coroutines.delay

val io = IO.fx {
    continueOn(NonCancellable)
    effect { println("STARTED") }.bind()
    effect { delay(10000) }.bind()
    effect { println("FINISHED") }.bind()
}

val disposable = io.unsafeRunAsyncCancellable {  }
disposable()

monad-comprehensins

StateMonad

flatMap

java.lang.NoSuchMethodError: arrow.typeclasses.Monad.getFx()Larrow/typeclasses/MonadFx

raceN

IO.fx {
        dispatchers().io().raceN(timer().sleep(10.seconds).followedBy(effect { println("Hello") }), effect { println("Hello world") })
            .fork().bind().join().bind()
}.suspended()

suspended()

Try

Try

Try

pTrySuccess

arrow.optics

arrow-optics/prism/README.me

Optics.kt

Try

Either

EitherT

mapLeft

fun <F> getSongUrlAsync(MS: MonadDefer<F>) =
  MS { getSongUrl() }

arrow.fx.typeclasses.MonadDefer

Eval

class ArrowRxTests {
    @Test
    fun `comprehension with arrow and rx`() {
        val x = SingleK.fx {
            val (count) = getCountSingle       // this is an async call using a SingleK.monadDefer
            val newCount = increment(count)    // this is an async call returning Single<Int>.... how do i use it here?
            newCount
        }.value()

        assertThat(x.blockingGet()).isEqualTo(2)
    }

    private fun getCount() = 1
    private fun <F> getCountAsync(MS: MonadDefer<F>) = MS.later { getCount() }
    private val getCountSingle: SingleKOf<Int> = getCountAsync(SingleK.monadDefer())

    private fun increment(i: Int): Single<Int> = Single.just(i + 1)
}

increment

SingleK.fx {}

Try

Try { … }

try { Either.right(…) } catch(e) { Either.left(…) }

runBlocking { Either.catch { … } }

EitherT<ForIO>

IO<Either<A, B>

run

run2

unsafeRunSync

run2

flatMap

fx

@Test
    fun `concurrent arrow and rx`() {

        val x = SingleK.fx {
            val requiredValue = !getCountSingle
            println("network call A")
            val networkCallAValue = !pauseAndIncrement(requiredValue).k()
            println("network call B")
            val networkCallBValue = !pauseAndIncrement(requiredValue).k()

            networkCallAValue + networkCallBValue
        }.value()

        assertThat(x.blockingGet()).isEqualTo(4)
    }

    private fun pauseAndIncrement(i: Int): Single<Int> {
        println("Entering pause...")
        Thread.sleep(2000)
        println("... returning single")
        return Single.just(i + 1)
    }

getCountSingle

Try { … }.toEither()

IO { … }.attempt().unsafeRunSync()

unsafeRunSync()

unsafeRunSync()

unsafeRunSync

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

[1..10]
|> List.map (add 2)
|> List.map (mult 3)

(1..10)
    .pipe { it.map { add(2) } }
    .pipe { it.map { mult(3) } }

(1..10)
    .map { add(2) }
    .map { mult(3) }

[9,12,15,18,21,24,27,30,33,36]

List<(Int) -> Int>

@optics

// TODO which we need to have access to the implementation of map in Option

fix()

fun add(a: Int, b: Int): Int = a + b

suspend fun main1(args: Array<String>) =
    IO.fx {

        val sc = Scanner(System.`in`)

        val nextInt = effect { sc.nextInt() }

        val added = IO.applicative()
            .map(nextInt, nextInt) { (a, b) -> add(a, b) }.bind()

        effect { println(added) }.bind()

    }.run { suspended() }

Either.fx() {
  val (x) = someLeftValue()
  10
} // Left propagates

Either.fx() {
  someLeftValue()
  10
} // Either.Right(10)

Kotlin

implicit

Scala

Arrow Meta

Scala

fun validatePhotoMatch(login: Login, photo: ByteArray): IO<Error, Unit> =
    IO.monad<Error>().fx.monad {
      val user = !userService.getUserByLogin(login)
      val modelVectors = !extractFaceVectors(user)
      val unknownVectors = !recognitionService.calculatePhoto(photo)
      val resultDto = !recognitionService.calculateDifference(unknownVectors, modelVectors)
      !failureOrUnit(resultDto.result)
    }.fix()

IO.fx {

IO.Companion.fx(c: suspend IOSyntax<E>.() -> A): IO<E, A>

IO.Companion.fx(c: suspend ConcurrentSyntax<IOPartialOf<Nothing>>.() -> A): IO<Nothing, A>

IO<Error, x>

val arrowVersion = "0.11.0-SNAPSHOT"
	implementation("io.arrow-kt:arrow-fx:$arrowVersion")
	implementation("io.arrow-kt:arrow-fx-reactor:$arrowVersion")
	implementation("io.arrow-kt:arrow-mtl:$arrowVersion")
	implementation("io.arrow-kt:arrow-mtl-data:$arrowVersion")
	implementation("io.arrow-kt:arrow-syntax:$arrowVersion")
	implementation("io.arrow-kt:arrow-integration-retrofit-adapter:$arrowVersion")
	kapt("io.arrow-kt:arrow-meta:$arrowVersion")

Either<E, A>.toIO<E, A>()

IO.monad<Error>().fx.monad {

IO.fx<MyError> { ... }