Retrofit

arrow-kt

class JSONRpcResponseEnvelopeConverter<T>(
    private val delegate: Converter<ResponseBody, JSONRpcResponseEnvelope<Any>>
) : Converter<ResponseBody, Either<Throwable, T>> {

    override fun convert(value: ResponseBody): Either<Throwable, T> {
        val response = delegate.convert(value)
        val error = response?.error
        return if (error == null) {
            Either.Right(
                response?.result as T
            )
        } else {
            Either.Left(
                InternalServerException(response.error)
            )
        }
    }
}

java.lang.RuntimeException: Failed to invoke private arrow.core.Either() with no args
	at com.google.gson.internal.ConstructorConstructor$3.construct(ConstructorConstructor.java:113)
	at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$Adapter.read(ReflectiveTypeAdapterFactory.java:212)
	at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$1.read(ReflectiveTypeAdapterFactory.java:131)
	at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$Adapter.read(ReflectiveTypeAdapterFactory.java:222)
	at retrofit2.converter.gson.GsonResponseBodyConverter.convert(GsonResponseBodyConverter.java:40)
	at retrofit2.converter.gson.GsonResponseBodyConverter.convert(GsonResponseBodyConverter.java:27)
	at com.tochka.bank.npd.core.network.JSONRpcResponseEnvelopeConverter.convert(JSONRpcResponseEnvelopeConverter.kt:12)
	at com.tochka.bank.npd.core.network.JSONRpcResponseEnvelopeConverter.convert(JSONRpcResponseEnvelopeConverter.kt:7)
	at retrofit2.OkHttpCall.parseResponse(OkHttpCall.java:243)
	at retrofit2.OkHttpCall$1.onResponse(OkHttpCall.java:153)
	at okhttp3.internal.connection.RealCall$AsyncCall.run(RealCall.kt:519)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1167)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:641)
	at java.lang.Thread.run(Thread.java:923)
Caused by: java.lang.InstantiationException: Can't instantiate abstract class arrow.core.Either
	at java.lang.reflect.Constructor.newInstance0(Native Method)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:343)
	at com.google.gson.internal.ConstructorConstructor$3.construct(ConstructorConstructor.java:110)
	... 13 more

abstract val

@optics
sealed class TestArrow {
    abstract val isSelected : Boolean

    companion object {}

    @optics
    data class Test1(override val isSelected: Boolean, val fooBar1: String) : TestArrow() {
        companion object {}
    }

    @optics
    data class Test2(override val isSelected: Boolean, val fooBar1: String) : TestArrow() {
        companion object {}
    }
    @optics
    data class Test3(override val isSelected: Boolean,  val fooBar1: String) : TestArrow() {
        companion object {}
    }
}

fun TestArrow.updateSelected(isSelected: Boolean) : TestArrow {
    return when(this) {
        is TestArrow.Test1 -> this.copy(isSelected = isSelected)
        is TestArrow.Test2 -> this.copy(isSelected = isSelected)
        is TestArrow.Test3 -> this.copy(isSelected = isSelected)
    }
}

refined-type

@JvmInline
@Serializable
value class GameId private constructor(val value: String) {
    companion object : Refined<String, GameId>(::GameId, {
        ensure((it.length == 8) to "Expected $it has 8 characters")
    })
}

@Serializable
data class Game(
    val gameId: GameId,
    val color: String,
)

fun main() {
    val json = """{"gameId":"abcd1234","color":"white"}"""
    println(Json.decodeFromString<Game>(json))
    val json2 = """{"gameId":"","color":"white"}"""
    println(Json.decodeFromString<Game>(json2))
}

Game(gameId=GameId(value=abcd1234), color=white)
Game(gameId=GameId(value=), color=white)

init

shouldBeLeft

arrow.core.Either$Left.getA()Ljava/lang/Object

f compose g

compose

Getter<S,A>

S

Option.lift

Iso

either

if (some condition) {
  val left: Either<Failure, DbUser> =
    UnknownFailure("some message here")
      .left()
  left.bind()
}

if (some condition)
    UnknownFailure("message").left().bind()

Either<Failure, Nothing>.

Mono / Flux

Either / Validated

parZip / parTraverse

Either.catch {}

try/catch

Either.catch {}

try/catch

try/catch

fun add(a: Int, b: Int): Int = a + b
val multiply: (Int, Int) -> Int = { a: Int, b: Int -> a * b }

val add3 = add.curried()(3) // does not compile
val multiply2 = multiply.curried()(2)

fun add(a: Int, b: Int): Int = a + b
fun add(a: String, b: String): Int = add(Integer.parseInt(a), Integer.parseInt(b))

fun <A, B> Collection<Either<A, B>>.allLefts(): List<A> = this.mapNotNull { either -> either.fold({ it }, { null }) }

return newStockItem.right()
    .flatMap { checkFirstThing(newStockItem) } 
    .flatMap { checkSecondThing(newStockItem) }

return checkFirstThing(newStockItem)
    .flatMap { checkSecondThing(newStockItem) }

MyType.foo.bar.every.baz.modify(obj) { someSuspendFun(it) }

@JvmStatic
    @JvmName("tryCatch")
    inline fun <A> catch(recover: (Throwable) -> Unit, f: () -> A): Option<A> =
      try {
        Some(f())
      } catch (t: Throwable) {
        recover(t.nonFatalOrThrow())
        None
      }

(Throwable) -> Unit

(Throwable) -> Option<A>

None

Some

@Transactional

Either

Either<Throwable, Something>

@Transactional

Left

Either

(Int) -> Either<Error, Int>

val c = either {
  val a = func1(1).bind()
  val b = func2(a).bind()

  b
}

val pipe = func2 composeK func1
val c = pipe(1)