nomisRev

// ./gradlew runs tests for all configured Apple targets
val appleTest = tasks.create("appleTest")

subprojects {
  afterEvaluate {
    val appleTargets = setOf("tvos", "watchos", "ios", "macos")

    extensions.findByType<org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension>()
      ?.sourceSets
      ?.filter { appleTargets.any { target -> it.name.contains(target) } && it.name.contains("Test") }

nomisRev

/**
 * In Arrow we only provide functions up to arity-9,
 * using Tuple we can easily compose up to arity-n.
 *
 * A small example to show Validated#zip for arity-18
 */

fun validated(): ValidatedNel<String, Int> =
  "example".invalidNel()

nomisRev

import arrow.core.Either
import arrow.core.computations.EitherEffect
import arrow.core.computations.either
import kotlinx.coroutines.Dispatchers
import org.jetbrains.exposed.sql.transactions.experimental.newSuspendedTransaction

typealias Query<E, A> = suspend () -> Either<E, A>

fun <E, A> query(f: suspend EitherEffect<E, *>.() -> A): Query<E, A> =
  suspend { either(f) }

nomisRev

import arrow.core.identity
import kotlin.coroutines.Continuation
import kotlin.coroutines.resume
import kotlin.coroutines.intrinsics.suspendCoroutineUninterceptedOrReturn
import kotlin.coroutines.intrinsics.startCoroutineUninterceptedOrReturn
import kotlin.coroutines.intrinsics.COROUTINE_SUSPENDED

interface ContEffect<R, A> {
  suspend fun <B> shift(r: R): B

nomisRev

• Creating computation DSL by weaving suspend functions: https://kotlinlang.slack.com/archives/C5UPMM0A0/p1631326397023700

nomisRev

The DSL uses the suspension system, but the Restricted version uses @RestrictSuspension.
This disallows any suspend function to be called inside the DSL except for the functions defined inside RestrictOptionEffect.
This means that the DSL can be evaluated immediately, or eagerly. Instead of requiring suspend.
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.coroutines/-restricts-suspension/

If you’re already inside a suspend context then it makes most sense to just use the suspend version. That’ll also allow you to use other suspending code inside the DSL

nomisRev

In Kotlin there is the concept of “co-pure”. The Kotlin compiler has a powerful inliner, which is very commonly used in Kotlin. An inliner takes the code from an inline fun, and puts it in the place of the call-site. So if an inline fun is pure in it’s definition, and it takes a lambda then the resulting code is pure if and only if the passed lambda is also pure. Otherwise the resulting code is impure. So the whether the resulting code pure or not depends 100% on the passed lambda.

fun pureExample(): Unit = 
  listOf(1, 2, 3).map { it + 1 } // [2, 3, 4] & pure

nomisRev

/**
 * Creates a pool with [n] resouces of [A].
 * It creates [n] resources of
 */
fun <A> Resource<A>.pool(n: Int): Resource<ClusteredResources<A>> =
    List(n) { this }.sequence()
        .flatMap { all ->
            Resource({
                ClusteredResources(
                    Channel<A>(all.size).apply {

nomisRev

// PROJECT A
val testsConfig by configurations.creating {
    extendsFrom(configurations["testImplementation"])
}
dependencies {
    testsConfig(sourceSets.getByName("test").output)
}
// PROJECT B
testImplementation(project(":projectA", "testsConfig"))

nomisRev

package com.github.nomisrev

import arrow.fx.coroutines.Resource
import arrow.fx.coroutines.fromAutoCloseable
import java.sql.Connection
import java.sql.PreparedStatement
import java.sql.ResultSet
import java.sql.Types
import javax.sql.DataSource