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

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

/*
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

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

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 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

import kotlin.coroutines.experimental.*
import kotlin.coroutines.experimental.intrinsics.*

fun main(args: Array<String>) {
    enumerate {
        if (flip("A")) {
            if (flip("B")) 1 else 2
        } else {
            if (flip("C")) 3 else if (flip("D")) 4 else 5
        }

elizarov

public class CancellableHandlerContext(
    private val handler: Handler
) : AbstractCoroutineContextElement(ContinuationInterceptor), ContinuationInterceptor, Delay
{
    override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =
        DispatchedContinuation(continuation)

    override fun scheduleResumeAfterDelay(time: Long, unit: TimeUnit, continuation: CancellableContinuation<Unit>) {
        handler.postDelayed(object : ResumeTask<Unit>(continuation) {
            override fun resume() = continuation.resume(Unit)

elizarov

import javafx.beans.property.SimpleStringProperty
import javafx.geometry.Insets
import javafx.scene.Scene
import javafx.scene.control.ButtonBar
import javafx.scene.control.ButtonType
import javafx.scene.control.Dialog
import javafx.util.Callback
import kotlinx.coroutines.experimental.CommonPool
import kotlinx.coroutines.experimental.javafx.JavaFx
import kotlinx.coroutines.experimental.launch