It requires a

fix()

at the end, no?

Hi, this might look like a noob question, I'm not even sure it isn't doable with the kotlin standard library… I'm looking to do a "simple" addition to a list, here's a simplified version of what I want:

data class Item(val name: String, val quantity: Int)
fun List<Item>.addItem(item: Item): List<Item> { ??? }
listOf(Item("apple", 3), Item("Pear", 1)).addItem(Item("apple", 2) // -> expected : listOf(Item("apple", 5), Item("Pear", 1))

What would be an FP version of

addItem

?

@noiano I would go to a terminal

IO<Unit>

then at the very edge where you need to perform the action you can call

unsafeRunAsync

or any other variation of that method to run the program. What

attempt

does is turn

IO<A>

into

IO<Either<Throwable, A>>

forcing the receiver of the last typed value to deal in composition with the fact that the operation may have failed with an exception which can be found in the Left

Tangentially related: I usually would

flatmap

over

Dataset<C>

->

IO<Unit>

in this case, assuming that

map

is intended for applying pure functions. I think that is the expected usage for those?

I would like to identify the UCs linked to the syntax

inline reified

in Arrow. For example, here :

inline fun <reified F> Free<ForAnkOps, ListK<File>>.run(interpreter: FunctionK<ForAnkOps, F>, MF: Monad<F>): Kind<F, ListK<File>> =
this.foldMap(interpreter, MF)

intuitively, this syntax is needed to typeclass instance look up. But how ? I did not find this syntax described and used outside of Arrow.

There is no way to thread the

B

type of

use

in

bracketCase

through the

ExitCase.Completed

part of

release

, is there?

@Bob Glamm I think the importance of Bracket becomes more apparent when you compare examples. For example the fact that coroutines are eager makes them an issue for error handling and safe resource release in some scenarios:

we'll be deploying a new version of the site soon

Hi, I've noticed arrow-core 0.9+ isn't on maven central; the docs instruct to include a custom

maven { url "<https://dl.bintray.com/arrow-kt/arrow-kt/>" }

repository. Will arrow not be published to maven central anymore?

Basic usage question: How do I satisfy a concrete return type to

Kind<F, A>

? For instance, I have a

List<Animal>

but want to return

Kind<F, Animal>

. Example:

interface AnimalMapper<F> : MonadError<F, Throwable> {

    fun Kind<F, FarmDto>.toAnimalsFromNetwork(): Kind<F, Animal> = flatMap { farmDto ->
        catch {
            farmDto.animalDtos.map {
                Animal(
                    it.id,
                    it.name
                )
            }
        }
    }
}

This yields a type inference error. Expected

Kind<F, Animal>

, but found

Kind<F, List<Animal>>

Hey #arrow - I’m attempting to implement a new module in my android app using @Jorge Castillo’s

tagless-final

example shown here: https://github.com/JorgeCastilloPrz/ArrowAndroidSamples/tree/master/tagless-final. Since my mathematical understanding of fp is low (I’ve been learning via gcanti’s

fp-ts

library) and my understanding of corountines in Android also low I feel like I’ve bitten off more than I can chew! Having run into a few more fundamental problems, where is best to chat about the problems I’m hitting? Here or create an SO ticket?

correct me if i'm wrong, but the map it.fix won't be necessary in some newer versions of arrow right?

Hello. Is it feasible to do a binding for Either that does not provide its own coroutine context? I'm working with a library that is not friendly to be enclosed in the binding because of that.

👋 anyone has type inference issues when using

Either.left && Either.right

within a

RxJava

. For example request.map { Either.right(it) }.onErrorReturn { Either.left(it) }` doesn’t compile

I think you need to cast like

request.map { Either.right(it) as Either<E,A>}.onErrorReturn { Either.left(it) }

I have some helper functions to make life easier when working with Either and RxJava: https://github.com/lenguyenthanh/RxArrow. Hope that can help you @laimiux.

Hello. Is there any design reason for Either.flatMap and Either.map not being inline anymore (it was inline in 0.8.2 and it isn't in 0.10.0)? It has become unfriendly to suspending functions after that.

oh god that API

If I use the

fun CompletionStage<V>.asIO(): IO<V> = IO.async

then I won't be able to have

fun <V> startThings(a: Async<V>) = object : MemSource<V>, Async<V> by a

. What am I missing that connects

IO<F>

to

Async<F>

?

Hello, hello! How do we switch CoroutineContexts within

IO.fx { ... }

? I tried starting the block with

continueOn(<http://Dispatchers.IO|Dispatchers.IO>)

but for some reason it hangs.

Hello all. I published a GIST (internal use at this stage but public in a near future) about my attempt to write a short DSL with Λrrow Free ! In the future, I'll write more articles for my team to feel better with Λrrow. What do you think about this format ? Feedback are wellcome to improve this draft... Thx to Λrrow team members for their help 😍 https://gist.github.com/PBastiani/26d8734ff33001cb0304df337ea936a1

@simon.vergauwen I was wondering your parTraverseN with semaphore solution made it to 0.10.0 ? I am using what you helped with now, if its there already, then I’ll just remove it ?

w.r.t. Scala about half of the Cats guys have moved over to Metals + LSP-capable editor

that looks okay to me, it’s

io.map { ei -> ei.map { l -> l.map { b -> toC(b) } } }

quick question about ANK let's say I have a sealed class in a code snippet:

sealed class ValidationResult<out E, out A> {
    data class Valid<A>(val a: A) : ValidationResult<Nothing, A>()
    data class Invalid<E>(val e: E) : ValidationResult<E, Nothing>()
}

And I want to use `Valid`/`Invalid` without prefixing with

ValidationResult

. How can I do that... I tried

import ValidationResult.Valid
import ValidationResult.Invalid

but it doesn't work.... Error I am getting is (when trying to use just `Valid`:

error: unresolved reference: Valid
            if (a is Valid && b is Valid) valid(f(a.a, b.a))

tail recursion only makes sense in Monads that blow the stack like List, Option, Either, etc… Async monads are stack safe because they trampoline when they run. If you look at the IO ADT you see all those flatMap and binds are nothing but creating a data structure that unfolds into a terminal value when you run IO at the edge. This value can be calculated by async or concurrent processes that would scape the stack.

tailrec

is designed so that recursive functions don’t blow up the stack but all async monads like IO are safe because they jump out of the stack before it fills up by moving the computation into the heap via ADTs and classes that hold computations in memory.

can I use fx block with

Kind<F, Option<Something>>

where

F

is

MonadError

? (arrow 0.10)?