Merge pull request #1 from h0tk3y/migration-to-1.1-M04

Updated to 1.1-M04.

build.gradle

@@ -1,5 +1,5 @@
 buildscript {
-    ext.kotlin_version = '1.1-M03'
+    ext.kotlin_version = '1.1-M04'
 
     repositories {
         mavenCentral()
@@ -19,6 +19,7 @@ repositories {
 
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    compile "org.jetbrains.kotlin:kotlin-reflect:$kotlin_version"
     testCompile "junit:junit:4.12"
 }
 

src/main/kotlin/com/github/h0tk3y/kotlinMonads/DoNotation.kt

@@ -1,55 +1,61 @@
+@file:Suppress("EXPERIMENTAL_FEATURE_WARNING")
+
 package com.github.h0tk3y.kotlinMonads
 
 import java.io.Serializable
 import java.util.*
-import kotlin.jvm.internal.CoroutineImpl
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.CoroutineIntrinsics
+import kotlin.coroutines.startCoroutine
 
 fun <M : Monad<M, *>, T> doWith(m: Monad<M, T>,
-                                coroutine c: DoController<M, T>.(T) -> Continuation<Unit>): Monad<M, T> {
-    return (m bind { x -> doWith(this, x, c) })
-}
+                                c: suspend DoController<M, T>.() -> Unit): Monad<M, T> =
+        m.bind { t -> doWith(this, t, c) }
+
 
 fun <M : Monad<M, *>, T> doWith(aReturn: Return<M>,
                                 defaultValue: T,
-                                coroutine c: DoController<M, T>.(T) -> Continuation<Unit>): Monad<M, T> {
+                                c: suspend DoController<M, T>.() -> Unit): Monad<M, T> {
     val controller = DoController(aReturn, defaultValue)
-    c(controller, defaultValue).resume(Unit)
+    c.startCoroutine(controller, object : Continuation<Unit> {
+        override fun resume(value: Unit) {}
+        override fun resumeWithException(exception: Throwable) = throw exception
+    })
     return controller.lastResult
 }
 
-private fun <T, R> backupLabel(c: Continuation<T>, block: Continuation<T>.() -> R): R {
-    val reflect = CoroutineImpl::class.java
-    val labelField = reflect.getDeclaredField("label")
+val labelField by lazy {
+    val jClass = Class.forName("kotlin.jvm.internal.RestrictedCoroutineImpl")
+    return@lazy jClass.getDeclaredField("label").apply { isAccessible = true }
+}
 
-    labelField.isAccessible = true
-    val l = labelField.get(c)
-    labelField.isAccessible = false
+var <T> Continuation<T>.label
+    get() = labelField.get(this)
+    set(value) = labelField.set(this@label, value)
 
+private fun <T, R> backupLabel(c: Continuation<T>, block: Continuation<T>.() -> R): R {
+    val backupLabel = c.label
     val r = block(c)
-
-    labelField.isAccessible = true
-    labelField.set(c, l)
-    labelField.isAccessible = false
-
+    c.label = backupLabel
     return r
 }
 
 class DoController<M : Monad<M, *>, T>(val returning: Return<M>,
-                                       initialValue: T) : Serializable {
-    var lastResult: Monad<M, T> = returning.returns(initialValue)
-        private set
+                                       val value: T) : Serializable, Return<M> by returning {
+    var lastResult: Monad<M, T> = returning.returns(value)
+        internal set
 
     private val stackSignals = Stack<Boolean>().apply { push(false) }
 
-    fun <T> returns(t: T) = returning.returns(t)
-
-    suspend fun bind(m: Monad<M, T>, c: Continuation<T>) {
+    suspend fun bind(m: Monad<M, T>): T = CoroutineIntrinsics.suspendCoroutineOrReturn { c ->
         stackSignals.pop()
         stackSignals.push(true)
         var anyCont = false
         val o = m.bind { x ->
             stackSignals.push(false)
-            backupLabel(c) { c.resume(x) }
+            backupLabel(c) {
+                c.resume(x)
+            }
             val contHasMonad = stackSignals.pop()
             if (contHasMonad) {
                 anyCont = true
@@ -59,9 +65,10 @@ class DoController<M : Monad<M, *>, T>(val returning: Return<M>,
             }
         }
         lastResult = if (anyCont) o else m
+        CoroutineIntrinsics.SUSPENDED
     }
 
-    suspend fun then(m: Monad<M, T>, c: Continuation<Unit>) {
+    suspend fun then(m: Monad<M, T>) = CoroutineIntrinsics.suspendCoroutineOrReturn<Unit> { c ->
         stackSignals.pop()
         stackSignals.push(true)
         var anyCont = false
@@ -77,6 +84,7 @@ class DoController<M : Monad<M, *>, T>(val returning: Return<M>,
             }
         }
         lastResult = if (anyCont) o else m
+        CoroutineIntrinsics.SUSPENDED
     }
 }
 

src/test/kotlin/com/github/h0tk3y/kotlinMonads/DoNotationTest.kt

@@ -1,3 +1,5 @@
+@file:Suppress("EXPERIMENTAL_FEATURE_WARNING")
+
 package com.github.h0tk3y.kotlinMonads
 
 import org.junit.Assert.assertEquals
@@ -6,8 +8,8 @@ import org.junit.Test
 
 class DoNotationTest {
     @Test fun testLinearDo() {
-        val m = doWith(just(1)) { i ->
-            val j = bind(returns(i * 2))
+        val m = doWith(just(1)) {
+            val j = bind(returns(value * 2))
             val k = bind(returns(j * 3))
             then(returns(k + 1))
         }
@@ -16,8 +18,8 @@ class DoNotationTest {
 
     @Test fun testControlFlow() {
         var called = false
-        val m = doWith(just(1)) { i ->
-            val j = bind(returns(i * 2))
+        val m = doWith(just(1)) {
+            val j = bind(returns(value * 2))
             val k = bind(if (j % 2 == 0) none() else just(j))
             called = true
             then(returns(k))
@@ -56,8 +58,8 @@ class DoNotationTest {
 
     @Test fun testBindLastStatement() {
         val results = mutableListOf<Int>()
-        val m = doWith(monadListOf(2)) { i ->
-            val x = bind(monadListOf(i + 1, i * i))
+        val m = doWith(monadListOf(2)) {
+            val x = bind(monadListOf(value + 1, value * value))
             val z = bind(returns(x))
             results.add(z)
         }