@extension

@higherkind
class Test<A>(val f: () -> A): TestOf<A> {
    companion object {}
}

@extension
interface TestFunctor : Functor<ForTest> {
    override fun <A, B> Kind<ForTest, A>.map(f: (A) -> B): Kind<ForTest, B> =
        Test { f(fix().f()) }
}

kaptKotlin

try catch

override fun f1(): Either<Errors.ApplicationError, AWSClient> =
            Try {
                try {
                    // logic1 here
                } catch (ex: Exception) {
                   // if logic1 throws exception then try logic2 in here
                }
            }.toEither().mapLeft {
                (Errors.UnexpectedError("Unexpected error: ${it}"))
            }

interface Eq<F> {
    fun F.eqv(b: F): Boolean
    fun F.neqv(b: F): Boolean = !eqv(b)
}

data class User(val id: Int) {
    companion object
}

@extension interface UserEq : Eq<User> {
    override fun User.eqv(b: User): Boolean = id == b.id
}

neqv

val user1 = User(1)
val user2 = User(2)

user1.neqv(user2)

eqv

eq

run

User.eq().run {
    user1.eqv(user2)
}

eqv

user1.eqv(user2) // right now, unresolved reference: eqv

fx

fxCancellable

fun foo(): Try<Unit> {
    return Try {
        1 // doesn't compile
    }
}

bind()

sealed class Cargo<T> {
  class Loading<T> : Cargo<T>()
  data class Loaded<T>(val cargo: T) : Cargo<T>()
  data class Error<T>(val cargo: T) : Cargo<T>()
}

override fun getCar(name: String): Either<CarNotFound, String?> {
        val carAttributes = loadCarAttributes(name)
        return when (carAttributes) {
            is Either.Right -> {
                return Right(carAttributes.b.attributes["carId"])
            }
            is Either.Left -> {
                Left(CarNotFound("car not found"))
            }
        }
    }

val carType = getCar("testname").fold( 
                        return Left({CarNotFound(it.message)}),
                        {it})
                )

(a -> b) -> (c -> d) -> p a c -> p b d

fun <A, B, C, D> Kind2<F, A, B>.bimap(fl: (A) -> C, fr: (B) -> D): Kind2<F, C, D>

(() -> b) -> (a -> B) -> Maybe a -> b

fun <A, B>Option<A>.fold(none: () -> B, some: (A) -> B): B

Either

Ior

IO

IO<E, A>

Fixed in #40

val (resultKind, disposable) =
                fxCancellable {
                    getAllCharactersCase.execute()
                }
        myDisposable = disposable
        val result: Try<CharacterList> = ...
        result.fold(
            ifFailure = {
                println(it.message)
            },
            ifSuccess = {
                displayResult(it)
            }
        )