WorkingBrackets.kt

package arrowdebug

import arrow.effects.extensions.io.fx.fx

import arrow.effects.IO

sealed class Error : RuntimeException()
object ClientInvalidQuery : Error()
object ClientQueryTimeout : Error()
object NotInTransaction : Error()


data class RAWSparqlResult(
    val variables: List<String>,
    val values: List<List<String>>
)

data class SparqlResult(
    val variables: List<String>,
    val values: List<List<String>>
)

class Dataset {
    var running = false

    fun start() {
        println("Starting dataset")
        running = true
    }

    fun end() {
        println("Called closing")
        running = false
    }
}

class QueryEngine(
    val query: String? = null,
    val dataset: Dataset? = null
) {
    fun execute(): RAWSparqlResult {
        //throw ClientQueryTimeout
        println("Currently ${dataset?.running}")
        if (dataset?.running == false) throw NotInTransaction
        return RAWSparqlResult(listOf("s", "p", "o"), listOf(listOf("a", "b", "c")))
    }
}


class TestClass {
    val dataset = Dataset()

    fun executeQuery(query: String, dataset: Dataset): QueryEngine {
        if (query == "Fail") {
            println("Throwing a fail")
            throw ClientInvalidQuery
        }
        return QueryEngine(query, dataset)
    }

    fun query(query: String): IO<SparqlResult> =
        fx {
            IO { dataset.start() }.bracket (release = {
                IO { dataset.end() }
            }, use = {
                println("Executing query ${dataset.running}")
                IO {
                    val results = executeQuery(query, dataset).execute()
                    SparqlResult(results.variables,
                        results.values.map { result ->
                            results.variables.map {
                                it + "Something"
                            }
                        }
                    )}
            }).bind()
        }
}

fun main() {
    val testclass = TestClass()
    println("A working query")
    testclass.query("Test").runAsync { result ->
        result.fold({ IO { println("Error $it") } }, { IO { println(it) } })
    }.unsafeRunSync()
    println("Transaction is now ${testclass.dataset.running}")

    println("A failing query")
    testclass.query("Fail").runAsync { result ->
        result.fold({ IO { println("Error $it") } }, { IO { println(it) } })
    }.unsafeRunSync()
    println("Transaction is now ${testclass.dataset.running}")
}