elizarov

import kotlinx.coroutines.experimental.CommonPool
import kotlinx.coroutines.experimental.launch
import kotlinx.coroutines.experimental.runBlocking
import java.util.concurrent.atomic.AtomicInteger
import kotlin.coroutines.experimental.AbstractCoroutineContextElement
import kotlin.coroutines.experimental.CoroutineContext
import kotlin.coroutines.experimental.intrinsics.*

// coroutine context element that keeps a (mutable) integer counter
class Counter : AbstractCoroutineContextElement(Key) {

elizarov

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val application = this
    launch(UI) { // start a new coroutine in Android UI context
        // switch to background thread for some long-running initialization
        run(CommonPool) { AndroidThreeTen.init(application) }
        // then init UI 
        initUI()
    }

elizarov

import kotlin.coroutines.experimental.*
import kotlin.coroutines.experimental.intrinsics.COROUTINE_SUSPENDED
import kotlin.coroutines.experimental.intrinsics.suspendCoroutineOrReturn

@RestrictsSuspension
abstract class StackComputation {
    abstract suspend fun <T> push(block: suspend StackComputation.() -> T): T
}

fun <T> compute(block: suspend StackComputation.() -> T): T =

elizarov

/*
fun BluetoothSocket.asyncListen(): Flowable<String> =
        flowable<String>(BackpressureStrategy.BUFFER) { emitter ->
            try {
                val reader = BufferedReader(InputStreamReader(inputStream))
                while (!emitter.isCancelled) {
                    reader.readLine()?.let { emitter.onNext(it) }
                }
            } catch (e: IOException) {
                emitter.onError(e)

elizarov

/*
fun BluetoothSocket.asyncListen(): Flowable<String> =
        flowable<String>(BackpressureStrategy.BUFFER) { emitter ->
            try {
                val reader = BufferedReader(InputStreamReader(inputStream))
                while (!emitter.isCancelled) {
                    reader.readLine()?.let { emitter.onNext(it) }
                }
            } catch (e: IOException) {
                emitter.onError(e)

elizarov

class Result<T> private constructor(private val result: Any?) {
    // discovery

    val isFailure: Boolean get() = result is Failure
    val isSuccess: Boolean get() = result !is Failure

    // value retrieval

    fun get(): T =
        if (result is Failure) throw result.exception

elizarov

Concurrency in Swift: One possible approach

• Author: Chris Lattner

Introduction

This document is published in the style of a "Swift evolution manifesto", outlining a long-term view of how to tackle a very large problem. It explores one possible approach to adding a first-class concurrency model to Swift, in an effort to catalyze positive discussion that leads us to a best-possible design. As such, it isn't an approved or finalized design

elizarov

import kotlinx.coroutines.experimental.runBlocking
import okhttp3.*
import java.io.IOException
import kotlin.coroutines.experimental.suspendCoroutine

fun main(args: Array<String>) {
    val http = OkHttpClient.Builder().build()
    val appid = "mock"
    val secret = "mock"
    val code = "mock"

elizarov

// https://akarnokd.blogspot.ru/2017/09/rxjava-vs-kotlin-coroutines-quick-look.html
import kotlinx.coroutines.experimental.*

suspend fun f1(i: Int): Int {
    Thread.sleep(if (i != 2) 2000L else 200L)
    return 1
}

suspend fun f2(i: Int): Int {
    Thread.sleep(if (i != 2) 2000L else 200L)

elizarov

// https://akarnokd.blogspot.ru/2017/09/rxjava-vs-kotlin-coroutines-quick-look.html
// Refactoring
import kotlinx.coroutines.experimental.*

suspend fun f1(i: Int): Int {
    Thread.sleep(if (i != 2) 2000L else 200L)
    return 1
}

suspend fun f2(i: Int): Int {