does something like that exist ?

are there some guidelines on writing your own typeclasses

so I want the kotlin version of declaring an

implicit Fibble[T]

Hey, is there something like

switchMap

in Arrow that can be used for scenarios like this:

Option
    .fromNullable(someValue)
    .map { /* calls a function that returns Either<Error, Value> */}

After calling map I have

Option<Either<Error, Value>>

wondering if there’s any way to avoid the extra wrapping. CC @Derek Seroky

Hmm, it's probably relatively straightforward to provide extension functions on types (.toCats/.fromCats) but I wonder if it's possible to compose algebras ... I guess probably not in general because no joint Scala/Kotlin compilation engine exists

remember the coversation we had the other day

.toEither()

and there will be some that won’t fit the bill, i.e. you wouldn’t use a List for Async. You simply cannot implement the interface in a way that passes the test suite that comes with Async.

I couldn't find it

what does suspend have to do with it

0.9.0?

do

IO.fx

Really need an #arrow-support channel for all of us plebes stuck staring at plain Java code that (for example) returns an un-bracketed

InputStream

while we know full well that what we really want there is

IO.bracket(...)

newbi question again Well, here I go again… I found pretty good this blog to understand monads and functors, etc. https://medium.com/beingprofessional/understanding-functor-and-monad-with-a-bag-of-peanuts-8fa702b3f69e But I am not sure if kotlin

map

6

flatMap

is just the same as explained there?

those will be executed one after another, I believe in 0.9 it’s second, first, third and Simon fixed it for 0.10 to be first, second, third

What's the difference between

"myerror".left()

and

"myerror".raiseError()

?

You can combine

Applicative.map

. Below is an example of combining 4 values by only using map with 2 params. Hope that helps :)

Validated.applicative().map(
  Validated.applicative().map(a, b, ::Tuple2),
  Validated.applicative().map(c, d, ::Tuple2) 
) { (a, b), (c, d=) -> ... }

What's the best way to wrap a coroutine in

IO

? (I'm a bit lost in the forest of

IO

,

Async

and

fx

constructors and combinators). Take this example:

suspend fun getCoroutines(internalHotelId: Int): Either<Throwable, CustomerFeedback?> { ... }

I'd like to execute it asynchronously. This is my take:

fun getIOAsync(internalHotelId: Int): IO<CustomerFeedback?> =
    IO.async().async { callback ->
      GlobalScope.launch {
        val result = GlobalScope.async { getCoroutines(internalHotelId) }.await()
        callback.invoke(result)
      }
    }
  }

Is this the correct way? Are there any other ways? Can this be achieved with

fx

and

effect

?

Hi, is there a cleaner way to do this:

class InMemoryStorePersistentSource : IStorePersistentSource {

    private var store: IO<Option<Store>> = IO { None }

    override fun getCurrentStore(): IO<Option<Store>> = store
    override fun persistCurrentStore(store: Option<Store>): IO<Unit> = IO { this.store = IO { store } }
}

also Kotlin 1.3.40 plugin for IJ includes the new type inference engine. Time to see if I can crash the GC!

Is it possible to extend ReceiveChannels into Traversable?

And there's no

Fx

instance for

EitherT

I’m confused about what is

Functor

,

Applicative

and

Monad

. How do you explain these terms for a programmer with OOP background/terminology?

Is there something like fun composed() = f() andThen g() andThen c()

For FP you have this one: https://github.com/spebbe/dartz I started doing a version of arrow for dart here: https://github.com/arrow-kt/cork There you can find some data type implementations. I don't have any plans currently to add support just yet, although may be in the future if there is interest.

@raulraja How to you rewind/restore the stack when dealing with observables that can run on different dispatchers/schedulers… That must not be easy to do…

Can you distribute a compiler plugin with the current artifacts so we still just need to include a few maven dependencies?

Does arrow have anything to handle a finally block? Something like

Try.invoke{canThrow()}.finally{cleanup()}