nope, with arrow library included

@kitttn https://try.arrow-kt.io:80

Also you could remove the

IO.run

if you use

IO.raiseError

instead. You’re already import binding for io directly with

import arrow.effects.extensions.io.monad.binding

🙂

meanwhile you’d need to use something like

EitherT<ForIO, MyError, A>

which is slower and boilerplaty

oh my, why is the documentation with the example: Arm a Nuke launcher Aim toward a Target Launch a Nuke and impact the Target Why not puppies and kittens playing together?

Hi. Can anyone explain to how this function gives me the ability to call a bind() function on an expression that returns an either, passed inside a lambda e.g. binding { val number = Either.right(2).bind() } When bind is not part of Eithers interface, and i can not call it when the expression is outside binding. Would also appreciate a link to Kotlin documentation that explains this Thanks 🙂

But I'm still really confused about what I should do when executeQuery throw an exception

Also a new binding still is supported. Where before you did always:

val a = ioValue.bind()

You can now do

val (a) = ioValue

in the example above, if the example in the middle throws an error, it just doesn't run the next effects

I have problems to compile and write own Semigroup Instances also the @instance annotation does not compile

Does anyone know what I am doing wrong..?

IO<Unit> ?

so I can write

when (call.response.status.value) {
                    200 -> effect { call.response.readText() }
                    404 -> IO.raiseError<String>(NonExistentReference).bind()
                    else -> IO.raiseError<String>(UnManagedReturnCode(call.response.status.value)).bind()
                }

Have you ever wrote JUNIT tests for Arrow code?

Will there be a vod of his talk?

Hello, I have a question about make

suspend

functions ‘functional’, possibly using Arrow-Fx. I threaded my question “How can I use

suspend

functions in a functional way” right here:

use

fx

Quick question: Is there a rough estimate on which this bug could be fixed? https://github.com/arrow-kt/arrow/issues/1295

If I have a

Kind<F, A>

(and its

Monad<F>

as well), how do I pry out the value of type

A

? In other word, how would I implement this extension function?

fun <F,A> Kind<F,A>.evaluateKind(monad: Monad<F>): A {
    // TODO Get and return the 'A' typed value from 'this' Kind<F,A>
}

@raulraja or @pakoito After this bug ( https://github.com/arrow-kt/arrow/issues/1295 ) is fixed, will the

fx { ... }

calls themselves be blocking or suspending? Looking at the Arrow code, the

fx { ... }

calls return a

returnedMonad

immediately (which could cause that #1295 bug). If this is fixed and its suspending lambda does not continue immediately, will the

fx

call be blocking or suspending to get the correct monad to be returned by it? I’m asking this especially for the

fx

calls returning

Either

,

Try

, etc values.

Wouldn’t it be easiest to just do

setOnClickListener { myCallback() }

. Least amount of typing, i think… 🙂

There should be a function available called

handleErrorWith

which exists for this exact situation.

Hi, my apologies for the cross post (already posted on gitter), just want to make sure this is seen, in case it is a bug in Fx. running this: https://gist.github.com/kartoffelsup/f749e2b1d0078a252204cfee82397463 I'm getting:

Exception in thread "main" java.lang.NoClassDefFoundError: Could not initialize class arrow.core.Either$Left
	at arrow.core.Either$Companion.left(Either.kt:173)
 	at arrow.core.EitherKt.Left(Either.kt:196)
 	at arrow.effects.IORunLoop.loop(IORunLoop.kt:182)
 	at arrow.effects.IORunLoop.startCancelable(IORunLoop.kt:27)
 	at <http://arrow.effects.IO|arrow.effects.IO>$Companion$asyncF$1.invoke(IO.kt:58)
 	at <http://arrow.effects.IO|arrow.effects.IO>$Companion$asyncF$1.invoke(IO.kt:26)
 	at arrow.effects.IORunLoop$suspendInAsync$1.invoke(IORunLoop.kt:145)
 	at arrow.effects.IORunLoop$suspendInAsync$1.invoke(IORunLoop.kt:17)
 	at arrow.effects.IORunLoop.loop(IORunLoop.kt:211)
 	at arrow.effects.IORunLoop.start(IORunLoop.kt:20)
 	at arrow.effects.IO.unsafeRunAsync(IO.kt:112)
 	at arrow.effects.internal.Platform.unsafeResync(Utils.kt:62)
 	at <http://arrow.effects.IO|arrow.effects.IO>$Async.unsafeRunTimedTotal$arrow_effects_data(IO.kt:183)
 	at arrow.effects.IO.unsafeRunTimed(IO.kt:135)
 	at arrow.effects.IO.unsafeRunSync(IO.kt:132)
 	at NoClassDefReproKt.main(NoClassDefRepro.kt:55)

Is this a bug or am I doing it wrong?

this has happened before

@Paolo Gavočanov Natural transformations are defined as FunctionK in Arrow

Isn't it a bit too dangerous to catch a Throwable in Try {}? I think this is why I had several NoClassDefFound Errors in my sample above (https://kotlinlang.slack.com/archives/C5UPMM0A0/p1550165387048700), because a StackOverFlowError was being caught. https://github.com/arrow-kt/arrow/blob/e82fcf69a35688584e3fb4e8e4ff44a44675c551/modules/core/arrow-core-data/src/main/kotlin/arrow/core/Try.kt#L39

Hello everyone, just a quick question, what's the proper way of immediately leaving a Option.monad().binding block or any other type? Is there a better way than just None.bind() (using Option, for example) ?

and a second semi-related question:

get(): A' is deprecated. This function is unsafe and will be removed in future versions of Arrow. Replace or import `arrow.syntax.unsafe.*` if you wish to continue using it in this way

how does one import

arrow.syntax.unsafe.*

? I can’t find that anywhere