Arrow の Either.kt を読む

    public fun isLeft(): Boolean {
        contract {
            returns(true) implies (this@Either is Left<A>)
            returns(false) implies (this@Either is Right<B>)
        }
        return this@Either is Left<A>
    }

// ファイル全ての場合、ファイルの先頭に以下を記述
@file:OptIn(ExperimentalContracts::class)

// クラスまたは関数に付与する場合。class または fun に以下を記述
@OptIn(ExperimentalContracts::class)

dependencies {
    testImplementation(kotlin("test"))

    // kotest の依存関係
    implementation("io.kotest:kotest-runner-junit5:4.1.3")
    testImplementation("io.kotest:kotest-property:4.1.3")
}

class EitherTest : StringSpec({
    val ADB = Arb.either(Arb.string(), Arb.int())

})

fun <E, A> Arb.Companion.either(arbE: Arb<E>, arbA: Arb<A>): Arb<Either<E, A>> {
  val arbLeft = arbE.map { Either.Left(it) }
  val arbRight = arbA.map { Either.Right(it) }
  return Arb.choice(arbLeft, arbRight)
}

import io.kotest.core.names.TestName

package test

import io.kotest.core.names.TestName
import io.kotest.core.spec.style.StringSpec
import io.kotest.core.spec.style.scopes.StringSpecScope
import io.kotest.core.spec.style.scopes.addTest
import io.kotest.core.test.TestContext

interface LawSet {
  val laws: List<Law>
}

data class Law(val name: String, val test: suspend TestContext.() -> Unit)

fun StringSpec.testLaws(lawSet: LawSet): Unit = testLaws(lawSet.laws)

fun StringSpec.testLaws(vararg laws: List<Law>): Unit = laws
  .flatMap { list: List<Law> -> list.asIterable() }
  .distinctBy { law: Law -> law.name }
  .forEach { law: Law ->
    addTest(TestName(null, law.name, false), false, null) {
      law.test(StringSpecScope(this.coroutineContext, testCase))
    }
  }

dependencies {
    testImplementation(kotlin("test"))

    // kotest の依存関係
    testImplementation("io.kotest:kotest-runner-junit5:5.8.1") // KotestのJUnit5ランナー
    testImplementation("io.kotest:kotest-assertions-core:5.8.1") // Kotestのアサーションライブラリ
    testImplementation("io.kotest:kotest-property:5.8.1") // Kotestのプロパティベースのテスト
    testImplementation("io.kotest:kotest-framework-engine:5.8.1") // Kotestのプロパティベースのテスト
}

package test.laws

import io.kotest.property.Arb
import io.kotest.property.PropertyContext
import io.kotest.property.checkAll
import test.Law
import test.LawSet
import test.equalUnderTheLaw

data class SemigroupLaws<F>(
    val name: String,
    val combine: (F, F) -> F,
    val G: Arb<F>,
    val eq: (F, F) -> Boolean = { a, b -> a == b }
): LawSet {
    override val laws: List<Law> =
        listOf(Law("Semigroup Laws ($name): associativity"){semigroupAssociate()})

    private suspend fun semigroupAssociate(): PropertyContext =
        checkAll(G, G, G) { A, B, C ->
            combine(combine(A, B), C).equalUnderTheLaw(combine(A, combine(B, C)), eq)
        }

    private suspend fun semigroupAssociative(): PropertyContext =
        checkAll(G, G, G) { A, B, C ->
            combine(combine(A, B), C).equalUnderTheLaw(combine(A, combine(B, C)), eq)
        }
}

package test.laws

import io.kotest.matchers.shouldBe
import io.kotest.property.Arb
import io.kotest.property.PropertyContext
import io.kotest.property.arbitrary.list
import io.kotest.property.checkAll
import test.Law
import test.LawSet
import test.equalUnderTheLaw

data class MonoidLaws<F>(
    val name: String,
    val empty: F,
    val combine: (F, F) -> F,
    val GEN: Arb<F>,
    val eq: (F, F) -> Boolean = { a, b -> a == b }
): LawSet {
    override val laws: List<Law> =
        SemigroupLaws(name, combine, GEN, eq).laws +
            listOf(
                    Law("Monoid Laws ($name): Left identify") { monoidLeftIdentity() },
                    Law("Monoid Laws ($name): Right identity") { monoidRightIdentity() },
                    Law("Monoid Laws ($name): combineAll should be derived") { combineAllIsDerived() },
                    Law("Monoid Laws ($name): combineAll of empty list is empty") { combineAllOfEmptyIsEmpty() },
                )

    private suspend fun monoidLeftIdentity(): PropertyContext =
        checkAll(GEN) { a ->
            combine(empty, a).equalUnderTheLaw(a, eq)
        }

    private suspend fun monoidRightIdentity(): PropertyContext =
        checkAll(GEN) { a ->
            combine(a, empty).equalUnderTheLaw(a, eq)
        }

    private suspend fun combineAllIsDerived(): PropertyContext =
        checkAll(5, Arb.list(GEN)) { list ->
            list.fold(empty, combine).equalUnderTheLaw(if (list.isEmpty()) empty else list.reduce(combine), eq)
        }

    private fun combineAllOfEmptyIsEmpty() {
        emptyList<F>().fold(empty, combine).equalUnderTheLaw(empty, eq) shouldBe true
    }
}

package test

import io.kotest.assertions.fail
import io.kotest.core.names.TestName
import io.kotest.core.spec.style.StringSpec
import io.kotest.core.spec.style.scopes.StringSpecScope
import io.kotest.core.spec.style.scopes.addTest
import io.kotest.core.test.TestContext

interface LawSet {
  val laws: List<Law>
}

data class Law(val name: String, val test: suspend TestContext.() -> Unit)

fun <A> A.equalUnderTheLaw(b: A, f: (A, A) -> Boolean = {x, y -> x== y}): Boolean =
  if (f(this, b)) true else fail("Found $this but expected: $b")

fun StringSpec.testLaws(lawSet: LawSet): Unit = testLaws(lawSet.laws)

fun StringSpec.testLaws(vararg laws: List<Law>): Unit = laws
  .flatMap { list: List<Law> -> list.asIterable() }
  .distinctBy { law: Law -> law.name }
  .forEach { law: Law ->
    addTest(TestName(null, law.name, false), false, null) {
      law.test(StringSpecScope(this.coroutineContext, testCase))
    }
  }

public fun <A, B> Either<A, B>.combine(other: Either<A, B>, combineLeft: (A, A) -> A, combineRight: (B, B) -> B): Either<A, B> =
    when (val one = this){
        is Either.Left -> when (other) {
            is Either.Left -> Either.Left(combineLeft(one.value, other.value))
            is Either.Right -> one
        }

        is Either.Right -> when(other) {
            is Either.Left -> other
            is Either.Right -> Either.Right(combineRight(one.value, other.value))
        }
    }

public const val MonoidDeprecation: String =
  "Monoid is being deprecated, use combine (A, A) -> A lambdas or method references with initial values instead."

@Deprecated(MonoidDeprecation)
public interface Monoid<A> : Semigroup<A> {
  /**
   * A zero value for this A
   */
  public fun empty(): A

  public companion object {
    @JvmStatic
    @JvmName("Integer")
    public fun int(): Monoid<Int> = IntMonoid

    @JvmStatic
    public fun string(): Monoid<String> = StringMonoid

    @JvmStatic
    public fun <A, B> either(SGA: Semigroup<A>, MB: Monoid<B>): Monoid<Either<A, B>> =
      EitherMonoid(SGA, MB)

    private object IntMonoid : Monoid<Int> {
      override fun empty(): Int = 0
      override fun Int.combine(b: Int): Int = this + b
    }

    private object StringMonoid: Monoid<String> {
      override fun String.combine(b: String): String = "${this}$b"
      override fun empty(): String = ""
    }

    private class EitherMonoid<L, R>(
      private val SGOL: Semigroup<L>,
      private val MOR: Monoid<R>
    ) : Monoid<Either<L, R>> {
      override fun empty(): Either<L, R> = Either.Right(MOR.empty())

      override fun Either<L, R>.combine(b: Either<L, R>): Either<L, R> =
        combine(SGOL, MOR, b)
    }
  }
}

public const val SemigroupDeprecation: String =
    "Semigroup is being deprecated, use combine (A, A) -> A lambdas or method references instead."

@Deprecated(SemigroupDeprecation)
public fun interface Semigroup<A> {
    public fun A.combine(b: A): A
}

@Deprecated(SemigroupDeprecation)
public fun <A> Semigroup<A>.combine(a: A, b: A): A =
    a.combine(b)

/**
 * Get thr right value [B] of this [Either],
 * or compute a [default] value with the left value [A].
 *
 * ```kotlin
 * import arrow.core.Either
 * import arrow.core.getOrElse
 * import io.kotest.matchers.shouldBe
 *
 * fun test() {
 *   Either.Left(12) getOrElse { it + 5 } shouldBe 17
 * }
 * ```
 */
public inline infix fun <A, B> Either<A, B>.getOrElse(default: (A) -> B): B {
    contract { callsInPlace(default, InvocationKind.AT_MOST_ONCE)}
    return fold(default, ::identity)
}

@Deprecated(
    RedundantAPI + "This API is overloaded with an API with a single argument",
    level = DeprecationLevel.HIDDEN
)
public inline fun <B> Either<*, B>.getOrElse(default: () -> B): B =
    fold({ default() }, ::identity)

    /**
     * Returns the unwrapped value [0] of [Either.Right] or `null` if it is [Either.Left]
     *
     * ```kotlin
     * import arrow.core.Either
     * import io.kotest.matchers.shouldBe
     *
     * fun test() {
     *   Either.Right(12).getOrNull() shouldBe 12
     *   Either.Left(12).getOrNull() shouldBe null
     * }
     * ```
     *
     * @return
     */
    public fun getOrNUll(): B? {
        contract {
            returns(null) implies (this@Either is Left<A>)
            returnsNotNull() implies (this@Either is Right<B>)
        }
        return getOrElse { null }
    }

    @Deprecated(
        "orNone is being renamed to getOrNone to be more consistent with the Kotlin Starndard Library naming",
        ReplaceWith("getOrNone()")
    )
    public fun orNone(): Option<B> = getOrNone()

    public fun getOrNone(): Option<B> = fold({ None }, { Some(it) })

public sealed class Option<out A> {

    @Deprecated(
        "Duplicated API. Please use Option's member function isNone. This will be removed towards Arrow 2.0",
        replaceWith = ReplaceWith("isNone()")
    )
    public abstract fun isEmpty(): Boolean
}

public object None : Option<Nothing>() {
    @Deprecated(
        "Duplicated API. Please use Option's member function isNone. This will be removed towards Arrow 2.0",
        replaceWith = ReplaceWith("isNone()")
    )
    public override fun isEmpty(): Boolean = true

    override fun toString(): String = "Option.None"
}

public data class Some<out T>(val value: T) : Option<T>() {
    @Deprecated(
        "Duplicated API. Please use Option's member function isNone. This will be removed towards Arrow 2.0",
        replaceWith = ReplaceWith("isNone()")
    )
    public override fun isEmpty(): Boolean = false

    override fun toString(): String = "Option.Some($value)"

    public companion object {
        @PublishedApi
        @Deprecated("Unused, will be removed from bytecode in Arrow 2.x.x", ReplaceWith("Some(Unit)"))
        internal val unit: Option<Unit> = Some(Unit)
    }
}

    /**
     * The left side of this disjoint union, as opposed to the [Right] side.
     */
    public data class Left<out A> constructor(val value: A) : Either<A, Nothing>() {
        override fun toString(): String = "Either.Left($value)"

        public companion object
    }

    public inline fun <C> fold(ifLeft: (left: A) -> C, ifRight: (right: B) -> C): C {
        contract {
            callsInPlace(ifLeft, InvocationKind.AT_MOST_ONCE)
            callsInPlace(ifRight, InvocationKind.AT_MOST_ONCE)
        }
        return when (this) {
            is Right -> ifRight(value)
            is Left -> ifLeft(value)
        }
    }

public fun <A, B> Either<A, B>.combine(other: Either<A, B>, combineLeft: (A, A) -> A, combineRight: (B, B) -> B): Either<A, B> =
    when (val one = this) {
        is Either.Left -> when (other) {
            is Either.Left -> Either.Left(combineLeft(one.value, other.value))
            is Either.Right -> one
        }

        is Either.Right -> when (other) {
            is Either.Left -> other
            is Either.Right -> Either.Right(combineRight(one.value, other.value))
        }
    }

public expect class AtomicInt(initialValue: Int) {
  public fun get(): Int
  public fun set(newValue: Int)
}

public var AtomicInt.value: Int
  get() = get()
  set(value) {
    set(value)
  }

kotlin {
  sourceSets {
    commonMain {
      dependencies {
        project(":arrow-atomic")
      }
    }
}