How do you properly mock an Either<> response? I have a function where I want to test the Left case, but using mockK this way gives me a Right(b=Left(a....))

every { someFunction(any()) } answers { Either.left("Go left")) }

Hi everyone. I’m having this error in an Android build using Arrow 0.10.5

Warning: arrow.core.extensions.ListKCrosswalk$crosswalk$1$2$1$1: can't find referenced class arrow.core.extensions.ListKCrosswalk$crosswalk$1$2
Warning: arrow.core.extensions.ListKCrosswalk$crosswalk$1$2$1$1: can't find referenced class arrow.core.extensions.ListKCrosswalk$crosswalk$1$2

I found this closed issue: https://github.com/arrow-kt/arrow/issues/807 Someone know if there is a workaround for this problem?

I guess I had glossed over fork() when reading about Queues / IO. I did read the article. I was just making sure I hadn't missed something in the arrow world before going with suspended() / coroutine scopes. Thanks for the help!

Slide-deck for my online talk about Arrow at Kotlin User Group, Hyderabad. Thanks for this Channel and Community for helping me 🙂 https://speakerdeck.com/gopalakshintala/template-oriented-programming-top-to-ship-faster

I'm I missing something, or current implementation of Queue cannot be functor?

Hi. I’m trying to do monad comprehension for

OptionT

. My stack is

IO<Option<User>>

. I cant figure out what to import to get

OptionT.fx.

I have tried importing arrow.mtl.extensions.fx like described here: https://arrow-kt.io/docs/0.10/arrow/mtl/optiont/, but that doesn’t work

Is there anything like

undefined

from Haskell, in Kotlin? I can of course just cast any value to the type i need, but just typing

any

would be easier 🙂

Hi, I’m looking for some examples on how to use JDBC with Arrow. I want to run a bunch of IO effects in a single DB transaction. Is it doable?

Hello Arrow people! Following this presentation from Runar () I was trying to reimplement the code written in Scala from the presentation (Free Monad + BolAlg) in Kotlin with Arrow. Unfortunately I got stuck 😕 In particular I do not understand what should be the type of

s

parameter in

Suspend

? You can find my implementation here: https://github.com/kuschanton/fp-in-kotlin/blob/master/src/main/kotlin/fp/kotlin/monad/free/Expr03.kt Any help appreciated 🙂 Kind regards, Arrow newbie

I don't believe that's a use case we have..or even like to have

what business logic requires it?

Also when working with Reader, it was a bit hassle when 3-4 function that have Reader as return type. I was `ask`ing and `extract`ing many times. Ofcourse that because of my limited fp exp. Perhaps ReaderT could’ve simplified it, but I never got it working 😞

mechanically, if you’re going to ignore the error anyway you might as well say it was Throwable all along

semantically, 

Either<Nothing, Either<Throwable, Int>>

 is correct

so you

fold({ exception }, { it.fold({ error }, { success })})

Hi guys. We’re replacing our custom made Optionnal with Arrow’s and I’m having a struggle chosing a syntax. What do you think? Both are the same? Or is there a prefered syntax? Or even a third option? (also, I have a few more like that 😄 hopefully, it has not already been answered a billion times 😄)

I'm working my way through the Red Book, trying to do some of the exercises in Kotlin. In chapter 9, there's an example that uses a type constructor (the book itself uses Scala).

trait Parsers[ParseError, Parser[+_]] {	
  def run[A](p: Parser[A])(input: String): Either[ParseError,A]
}

I've tried to express this using Arrow as below:

class ForParser private constructor()
typealias ParserOf<T> = Kind<ForParser, T>
inline fun <T> ParserOf<T>.fix(): Parser<T> = this as Parser<T>

class Parser<A>(val v: A) : ParserOf<A>

interface Parsers<ParseError> {
    fun <A> run(p : Parser<A>) : (String) -> Either<ParseError, A>
    fun char(c : Char) : Parser<Char>
}

So, this is my first pass which actually doesn't give any compile-time errors. But I'm confused by a few points: • Parsers interface is now only generic on the error and not on the Parser, what am I missing and how do I express it? • What is the syntax for the annotation

@higherkind

to eliminate the first three lines of boilerplate? If I just annotate the Parser class, ParserOf is flagged as undefined. • I'm not calling fix() anywhere, would I do that in the concrete implementation? • Scala seems to have a nice syntax for declaring curried functions and I've eliminated the named parameter input when I translated the run function. Is there a better way to express this? BTW Found this talk really helpful https://yowconference.com/talks/jacob-bass/yow-lambda-jam-2018/higher-kinded-types-in-a-lower-kinded-language-functional-programming-in-kotlin-code-jam-6368/

Is there a document somewhere with a comprehensive list of future plans? I've heard about many depreciations, the Meta plugin removing the need to fix, etc. Is there a list somewhere to explain what major changes are to come?

we already have it on arrow-syntax

Hi, Is the

IO.unsafeRunSync()

so dangerous that it cannot be called in production code? I need to execute

IO

in the current thread and

unsafeRunSync

seems reasonable in such case. Questions: 1. What can go wrong during the execution of

unsafeRunSync

? 2. How to execute

IO

in the current thread?

Hi! What is the recommended way to do circuit breakers with arrow? I have a project with arrow core but I am not to eager to add resilience4j, because it brings vavr and it is going to be confusing to mix with arrow.

if circuit breakers is what I think they are, flatMap with Option/Either/Validated should be enough

Hi, I'm new to arrow and already passionate, and try to use IO with Either to have a typed error but I'm stuck with the composition of dependent function like:

fun x() : IO<Either<Failure,String>>
    fun y(xResult: String) : IO<Either<Failure,Int>>
    fun z(yResult: Int) : IO<Either<Failure,String>>

It's my design totally wrong?

It's fine for now, unless you want to type your errors as throwables and use IO<A>. In 0.11.0 IO<E, A> is coming, and you'll be able to drop the nested Either.

Can arrow be used without kapt? Just the monad implementations for option either etc?

Hi, I'm new to Kotlin and I just started playing with Arrow and I can't understand something. This is an example from the documentation:

fun magic(s: String): Either<Exception, String>

val x = magic("2")
val value = when(x) {
    is Either.Left -> when (x.a){
        is NumberFormatException -> "Not a number!"
        is IllegalArgumentException -> "Can't take reciprocal of 0!"
        else -> "Unknown error"
    }
    is Either.Right -> "Got reciprocal: ${x.b}"
}

And above the code, the following is written: You should also notice that we are using SmartCast for accessing 

Left

 and 

Right

 values. I expected that to mean that after matching X with Either.Left, the compiler would know that x is of type Exception (and the same for right, but there that x is of type String). Here you still have to call .a or .b to get the value. So sorry if this is a stupid question, but what exactly is smart casted here and would it be possible to get Kotlin to know that x is of type String after matching it with Right here?

Hey, anybody knows why the

catch

function from the

Either

is a suspend function? Is it possible to catch an exception without using an

IO

?

What would be an idiomatic way to create Either if I am not assigning it to a variable so I can't specify its exact type. To be more precise, I am trying to convert a Result to Either. If Result is Ok want to give that value to right, if Results contain a Throwable I set left to sam error. Code is something like this:

fun <T : Any> Result<T>.toEither(): Either<RequestError, T> =
    fold({ Either.right(it)}, {Either.left(calculateError())})

However, this doesn't compile (although Intellij doesn't show that anything is wrong with the code), as

Either.right

creates

Either<Nothing, T>

and

Either.left

creates

Either<T, Nothing>

, so neither branching of the fold returns the needed type. Can I create wanted Either here (without having to create it with val, specify its exact type and returning that). I hoped simply doing something like

Either<RequestError, T>.right

would work, but of course it doesn't 😄

handleErrorWith

?

Hello everyone! I use v0.11.0-SNAPSHOT and I encountered an issue (at least in my understanding):

class OneError
class TwoError

private fun oneEither(): Either<OneError, String> = OneError().left()
private fun twoEither(value: String): Either<TwoError, Int> = value.toInt().right()

fun either() {
   oneEither()
     .flatMap { twoEither(it) }
     .fold(
       { throw Exception(it::class.simpleName) },
       { ... }
     )
}

private fun oneIO(): IO<OneError, String> = IO.raiseError(OneError())
private fun twoIO(value: String): IO<TwoError, Int> = IO.just(value.toInt())

fun io() {
   oneIO()
     .flatMap { twoIO(it) }
     .unsafeRunSyncEither()
     .fold(
       { throw Exception(it::class.simpleName) },
       { ... }
     )
}

The function

either

throws

java.lang.Exception: OneError

as I expect. But the function

io

throws

OneError cannot be cast to class TwoError

. When I look at the signature of

flatMap

(

fun <E, A, B, E2 : E> IOOf<E, A>.flatMap(f: (A) -> IOOf<E2, B>): IO<E2, B>

), I think that it shouldn't even compile. Can you tell me if my understanding is correct? I expect that

IO

with two types should behave like

Either

.