I am trying to do something very basic like

Either.Right("SOMETHING").map{it.toLowerCase()}

and I'm getting

Cannot access 'arrow.Kind' which is a supertype of 'arrow.core.Either'

I already have arrow-core 0.10.5 and arrow-core-data 0.10.5 is there another library I need to bring in?

Hi Guys! I am wondering is there any generic function in arrow that helps turn a bunch of nullable values into a one nullable value given a function e.g. data class constructor, it could be smth like this:

fun <A, B, C, D> fromNullable(a: A?, b: B?, c: C?, f: (A, B, C) -> D): D?

android-ui or android-arch is something we’ve toyed with in the past. @Miguel Coleto knows about comonadic UIs, and I believe @aballano was interested at some point. What we’re missing is someone to take the initiative and drive the project to completion 😄 So if you’d like to take it and learn while you write, that’s how several other projects like Optics happened.

In my project I've defined the following extensions to avoid having to declare the id monad on Reader map and flatmap.

/**
 * Extension function that fixes `Reader` so that you can `map` without needing to pass
 * `arrow.core.Id.monad()` explicitly.
 */
fun <D, A, B> Reader<D, A>.map(f: (A) -> B): Reader<D, B> {
  return this.map(arrow.core.Id.monad()) { f(it) }
}

/**
 * Extension function that fixes `Reader` so that you can `flatMap` without needing to pass
 * `arrow.core.Id.monad()` explicitly.
 */
fun <D, A, B> Reader<D, A>.flatMap(f: (A) -> KleisliOf<D, ForId, B>): Reader<D, B> {
  return this.flatMap(arrow.core.Id.monad()) { f(it) }
}

Is there any blocker for actually just making Reader work this way in the lib? Is there any other monad instance that is valid for Reader?

Hi arrow folks, I'm currently working on the FP in Kotlin chapter that deals with Monads 🎉 I've gotten to a point where I can't really express what I want to in Kotlin, and was hoping that Arrow could help me out here!

Arrow Fx + MTL

override fun open(
        no: String,
        name: String,
        rate: Option<BigDecimal>,
        openingDate: Option<LocalDate>,
        accountType: AccountType
    ): AccountOperation<Account> = Kleisli.invoke { repo ->
        EitherT(
            repo.query(no).flatMap { accountOptionOrError ->
                accountOptionOrError.fold(
                    { IO { MiscellaneousDomainExceptions(it).left() } },
                    { accOpt ->
                        accOpt.fold(
                            {
                                when (accountType) {
                                    AccountType.CHECKING -> createOrUpdate(
                                        repo,
                                        Account.checkingAccount(no, name, openingDate, None, Balance())
                                    )
                                    AccountType.SAVINGS -> rate.map { r ->
                                        createOrUpdate(
                                            repo,
                                            Account.savingsAccount(no, name, r, openingDate, None, Balance())
                                        )
                                    }.getOrElse { IO { RateMissingForSavingsAccount.left() } }
                                }
                            },
                            { IO { AlreadyExistingAccount(<http://it.no|it.no>).left() } }
                        )
                    }
                )
            }
        )
    }

the future:

override suspend fun AccountRepository.open(
        no: String,
        name: String,
        rate: BigDecimal?,
        openingDate: LocalDate?,
        accountType: AccountType
    ): Either<AccountServiceException, Account> = either {
        val existing = query(no).mapLeft { MiscellaneousDomainExceptions(it) }.bind()
        existing.rightIfNull { AlreadyExistingAccount(no) }.bind()

        val accountOrError = when (accountType) {
            AccountType.CHECKING -> Account.checkingAccount(no, name, openingDate, null, Balance())
            AccountType.SAVINGS -> {
                val r = rate.rightIfNotNull { RateMissingForSavingsAccount }.bind()
                Account.savingsAccount(no, name, r, openingDate, null, Balance())
            }
        }
        createOrUpdate(this@open, accountOrError).bind()
    }

the future is bright 😄

What is the relationship between use of typeclasses (or the Kotlin equivalent of interfaces with extension functions) and functional programming? Neither are required for core FP goals such as immutability, purity, and referential transparency. So, why does this pattern repeatedly show up in FP?

Is there a

filterOrElse

equivalent for BIO? Currently I had to write like this to set BIO to left of right state based on a boolean result (which feels boilerplate)

val example: (IO<String, Int>) -> IO<String, Any?> =
                { valueIO ->
                    valueIO.map(::someBooleanResult)
                            .flatMap { if (it) IO.just(it) else IO.raiseError("error") }
                }

you may be missing an import

Given such a data structure

data class X(val name : String)
data class Y(val x1: X, x2: X, x3 :X, x4: X)

Is there an easy way to change the

name

value of all ocurrences of

X

instances in

Y

? Using optics perhaps? Something like this:

val y = Y(...)
val newY = changeAllNames(y) {it + "foo"}

Hi. How do I get

//metadebug

-annotated classes to be displayed on compilation? is there some compiler switch or something? I cloned the arrow-meta-examples project but nothing gets printed into compiler output even though

//metadebug

is clearly there

I'm using the typeclassless style of DI via interface composition.

class G
class H

interface A<T> {
    fun T.foo(t: T): T
}

interface B : A<G>

interface C : A<H>

interface E : B, C // Compiler error: Type parameter T of 'A' has inconsistent values: InterfaceComposition.G, InterfaceComposition.H

Is there a way to get around the compiler error? My use case is that A is a generic handler of events of type T. So B and C are specific handler implementations for the events G and H. I would like to be able to do:

val a: A = TODO()
when (a) {
   is B, is C -> a.foo(..)
   else -> TODO()
}

Without a common base interface, I'd have to do:

val a: A = TODO()
when (a) {
   is B -> a.foo(..)
   is C -> a.foo(..)
   else -> TODO()
}

Thanks!

Does anyone know about article or else that compare the android app size made using arrow library and other library?

Does Arrow have something equivalent to Parallel in Cats, that abstracts over Monads but also supports parallel composition?

If I do a partraverse, what would be the correct way to limit the number of elements that gets executed in parallel?

oh ok now we need two types for IO

hmm I'm using that library in another software that is not using arrow, so I was using unsafeRunSync() , but it doesn't seem to exist anymore either

I'm rather curious on how coroutines are used to implement monad comprehensions on Kotlin. I believe I got the overall idea, however I'm failing to see the rationale for this "save and restore": • https://github.com/arrow-kt/arrow-core/blob/master/arrow-core-data/src/main/kotlin/arrow/typeclasses/MonadContinuations.kt#L35 • https://github.com/arrow-kt/arrow-core/blob/master/arrow-core-data/src/main/kotlin/arrow/typeclasses/MonadContinuations.kt#L37 Does anyone has any pointers to help clarify this? Namely, that save-restore always required? Thanks!

How is the term

syntax

used in naming classes or packages in Arrow or apps that use Arrow? I've seen this pattern before, but I don't recall where. Is it used interchangeably with the term

ops

? Or maybe it was in Scala code...

How is the recommended typeclassless DI technique different from the not-recommended Cake pattern from Scala? Swap out extension functions for regular ones, and are they basically the same?

Having made the switch to extensive use of extension functions, I'm struggling with how to organize them. OO was simpler in this way, because you simply added methods to the objects on whose data the methods operated, mostly. What general strategies do others apply in the context of FP? What's the impact of these strategies on unit testing the extension functions? For example, when extension functions on different receivers are all top-level and so share the same scope, isn't it more tricky to tease them apart in order to unit test each function in isolation from the others it may depend on in that scope? Or, in this scenario, does the "unit" in unit testing become the function under test AND all the other functions that it calls? If so, doesn't that become unwieldy as functions stack up on top of each other?

Hello 👋 I am trying to use fibers to concurrently load data chunks but I do not fully understand how it works with IO when I fork/join/bind Fiber. My IO continue to run on another thread (from worker pool) but initially started on ‘http-io’. I want to fire some IO heavy operations earlier, then fire a few more and start awaiting. I have an IO.fx block where I create different IO and then fork them. I want to run them concurrently on dispatchers().io() and so far they are running ok. But I notice by console-log-debugging that after first joining fiber IO is running on another thread. Are there any options or probably another class for this use case?

Has anyone had any problems pulling the 0.11.0-SNAPSHOT libraries lately? We’re using gradle to build, and I don’t think we’ve made any changes around dependencies or build process recently. Been seeing errors like this, when pulling arrow-kt libraries:

[2020-06-29T19:32:38.437Z] * What went wrong:
[2020-06-29T19:32:38.437Z] Execution failed for task ':core:kaptGenerateStubsKotlin'.
[2020-06-29T19:32:38.437Z] > Could not resolve all files for configuration ':core:compileClasspath'.
[2020-06-29T19:32:38.437Z]    > Could not resolve io.arrow-kt:arrow-mtl:0.11.0-SNAPSHOT.
[2020-06-29T19:32:38.437Z]      Required by:
[2020-06-29T19:32:38.437Z]          project :core
[2020-06-29T19:32:38.437Z]       > Could not resolve io.arrow-kt:arrow-mtl:0.11.0-SNAPSHOT.
[2020-06-29T19:32:38.437Z]          > Unable to load Maven meta-data from <https://oss.jfrog.org/artifactory/oss-snapshot-local/io/arrow-kt/arrow-mtl/0.11.0-SNAPSHOT/maven-metadata.xml>.
[2020-06-29T19:32:38.437Z]             > Could not get resource '<https://oss.jfrog.org/artifactory/oss-snapshot-local/io/arrow-kt/arrow-mtl/0.11.0-SNAPSHOT/maven-metadata.xml>'.
[2020-06-29T19:32:38.437Z]                > Could not GET '<https://www.jfrog.com/error?from=oss.jfrog.org&by=nginx-shared4c.gcoss-use1.jfrog.local>'. Received status code 403 from server: Forbidden

Oddly enough, if I visit one of those oss.jfrog.org urls directly, I’m able to download that metadata file

Good day all, I'm looking for feedback on two bits now that I'm a few weeks into my FP journey (which I love more every day 🙏 😍 :arrow:). Firstly I'm finding myself turning everything into a comprehension ... is that optimal or is it over zealous? Secondly, I've been toying with extension functions when I encounter different/nested combinations like Either<Either...>. In my current use case I have

Either<A, List<Either<A, B>>

so I've created two extension functions to unpack it:

fun <L, R> List<Either<L, R>>.splitLeftAndRight(): Tuple2<List<L>, List<R>> {
    val left = mutableListOf<L>()
    val right = mutableListOf<R>()

    forEach {
        when (it) {
            is Either.Left -> left += it.a
            is Either.Right -> right += it.b
        }
    }

    return Tuple2(left.toList(), right.toList())
}

fun <A, B, C> Either<A, List<Either<A, B>>>.flattenAndMap(f: (Tuple2<List<A>, List<B>>) -> C): Either<A, C> =
    when (this) {
        is Either.Left -> a.left()
        is Either.Right -> {
            f(b.splitLeftAndRight()).right()
        }
    }

And now in my comprehension becomes:

.map {
  // something that returns Either<A, List<Either<A, B>>>
}
.flattenAndMap { (lefts, rights) ->
  log.warn { "Filtering nested lefts: $lefts" }
  rights
}

So my question here is, does this approach make sense, or is there something wrong with it/I've missed something in the FP toolbox that would make my life easier? Thank you!

hi, is there something like mapN for Validated? Something like:

fun <V1, V2, ..., V22, E, R)validatedMapN(v1: Validated<E,V1>, v2: Validated<E,V2>, ..., v22: V22, sg: Semigroup<E>, f: (V1, V2, ..., V22)->R): Validated<E, R>

Is Arrow multiplatform yet?

Hi folks, I was just looking at the

curry()

extension methods on functions of arity 2 in arrow-core: https://github.com/arrow-kt/arrow-core/blob/master/arrow-core-data/src/main/kotlin/arrow/core/predef.kt#L5