Talking about Option, what are the solutions in Arrow for this issue?: https://discuss.kotlinlang.org/t/kotlin-null-check-for-multiple-nullable-vars/1946

If you had software that was fundamentally impure (eg. You have a few type of actions that you can do, but you only know which one should be executed, in which order, and how many times, from user input. How would you write it to be functional? An example could be to parse a background program's output and detect when it requires user input (confirmation, additional input...), and display that input in a UI to the user; ahead of time it's possible to know which actions exist, but not which will be used, how many times or even in which order

a function that takes in 2 reactive streams and returns a new one, would it be pure ?

How ‘good practice' is it to return a

Flow<Either<ErrorType, SuccessType>>

? Is there a specific type for this, or is it fine?

Any suggestions how to fix below? the code is something. like either{ foo() } where foo is suspend fun.

java.lang.IllegalStateException: No further work to do but also no result!
	at arrow.continuations.generic.DelimContScope.invoke(DelimContScope.kt:96)
	at arrow.continuations.generic.DelimContScope$Companion.reset(DelimContScope.kt:120)
	at arrow.core.computations.either.invoke(either.kt:27)

@simon.vergauwen @stojan Hi Stojan.. Simon! just had a quick look at your BirthdayKata using arrow-fx-coroutines, and I wonder, if you have any news about that IntelliJ Inspection "inappropriate blocking call" ? (referring to your post here https://kotlinlang.slack.com/archives/C5UPMM0A0/p1577273494147800?thread_ts=1577209740.144600&cid=C5UPMM0A0 ) So I guess this is an unresolved issue with IntelliJ's Kotlin plugin and arrow-fx-coroutines would be fine (?) with a solution like this:

how to set up Android app to be able to use

@Given

dependency injection with Arrow Meta? Follow implementation steps but am getting Gradle errors. https://github.com/arrow-kt/arrow-meta-examples

A while ago I wrote a document explaining the internals of Kotlin Coroutines from the standard library, and how it relates to the internals of Arrow Fx Coroutines as a contributors guide, or for anyone interested in better understanding the internals. This has never been promoted or shown anywhere in a visible place, where would you expect to find/see this? Any feedback on the README is also welcome 😉 https://github.com/arrow-kt/arrow-fx/tree/master/arrow-fx-coroutines

i'd love to hear it!

because i can have a

data class User(name: String = "", age: Int = -1)

that's an "empty" container and i can add to it with

copy(name="xul")

although I could make this work if

User

took a

Map

and i'd delegate `User`s fields to the

Map

Hei.

either {
    val (value1, value2) = parTupleN(
        suspend { someMethodReturningEither() },
        suspend { someMethodReturningEither() }
    )
    .right()
    .flatMap { (first, second) -> first.mproduct { second } }
    .bind()

    val (value1, value2) = parTupleN(
        suspend { someMethodReturningEither().bind() },
        suspend { someMethodReturningEither().bind() }
    )
}

Is there a difference between the two in terms of how parallelism will be done ? This question is because how I was used to do

parTupledN

with

IO

. There the results were always flatMapped and used to give

IO<Tuple2<A, B>>

Apologies for asking to use this channel for a code review. But I am getting to grips with functional programming, and am not sure where else to turn. The following code is to parse a string representing a polygon in the form [[1.0, 2.0],[2.0,3.122],...]. If I were not returning an Either from the function, instead returning the polygon or throwing, I would simply map over the matchResult and throw if it is unable to parse one of the x, y doubles. I'm not sure if there is a way to map over something, but escape early with an Either.left if there is an issue handling one of the map values? Here is the code as it stands now. I believe it works; I'm just not sure if there is a more idiomatic way to achieve this using Arrow?

internal fun polygonStringToPolygon(polygonString: String): Either<String, Polygon> {
    fun collectResults(
        results: Iterable<MatchResult>,
        acc: MutableList<Position> = mutableListOf()
    ): Either<String, List<Position>> {
        if (results.none()) {
            return Either.right(acc.toList())
        }
        val (match, rest) = results.splitAt(1)
        val x = match.single().groupValues.getOrNull(1)?.toDoubleOrNull()
        val y = match.single().groupValues.getOrNull(2)?.toDoubleOrNull()
        return if (x == null || y == null) {
            Either.left("Unable to parse polygon")
        } else {
            acc.add(Position(x, y))
            collectResults(rest, acc)
        }
    }

    val regex = "\\[([0-9]*.[0-9]*),([0-9]*.[0-9]*)]".toRegex()
    val matchResult = regex.findAll(polygonString)

    return collectResults(matchResult.asIterable())
}

Apologies in case I am missing something obvoius, but I was not following arrow-fx-coroutines for a while now. So using arrow-fx-coroutines 0.11.0, should this be possible with Kotlin 1.4.20 ?

fun f1() = Either.right("Ok")

fun f2(message: String): Either<String, String> {
    return if (message == "Ok")
        Either.right("totally Ok")
    else
        Either.left("Not Ok")
}

suspend fun main() {
    either {
        val r1 = f1().bind()
        val r2 = f2(r1).bind()
        println(r2)
    }
}

I am getting this compiler error: File being compiled: (9,1) in /home/jw/KotlinProjects/kalidation/src/main/kotlin/test.kt The root cause java.lang.IllegalStateException was thrown at: org.jetbrains.kotlin.codegen.state.KotlinTypeMapper$typeMappingConfiguration$1.processErrorType(KotlinTypeMapper.kt:109) at org.jetbrains.kotlin.codegen.MemberCodegen.genSimpleMember(MemberCodegen.java:203) at org.jetbrains.kotlin.codegen.PackagePartCodegen.generateBody(PackagePartCodegen.java:95) at org.jetbrains.kotlin.codegen.MemberCodegen.generate(MemberCodegen.java:129) at org.jetbrains.kotlin.codegen.PackageCodegenImpl.generateFile(PackageCodegenImpl.java:149) at org.jetbrains.kotlin.codegen.PackageCodegenImpl.generate(PackageCodegenImpl.java:70) ....etc. I don' remeber that using ".bind()" should be necessary, so what import for the monadic either-computation block shoul I be using here ?

Hey guys, In order to be able to use a lens do I need to know the specific subtype? I have a sealed class with its subtypes, which contains an abstract list of objects:

@optics
sealed class AbstractUser : User() {
    abstract val infos: List<UserInfo>

   //subclassing data classes here
}

At some point I need to modify the

infos

list and I don’t know which subtype it is. I don’t suppose it’s possible to use a lens here, is it?

Hey folks. I have super newbie question. Just started using

Either

(coming from Scala) and can't get

traverse

and

sequence

to work 😅 . I have all of this already in my

build.gradle

implementation "io.arrow-kt:arrow-core:$arrow_version"
    implementation "io.arrow-kt:arrow-syntax:$arrow_version"
    implementation "io.arrow-kt:arrow-core-data:$arrow_version"
    implementation "io.arrow-kt:arrow-fx-rx2:$arrow_version"
    implementation "io.arrow-kt:arrow-fx-reactor:$arrow_version"
    implementation "io.arrow-kt:arrow-mtl:$arrow_version"

but none of this works

import arrow.core.Either
import arrow.core.Option
import arrow.core.computations.either
import arrow.core.extensions.either.applicative.applicative
import arrow.core.extensions.list.traverse.sequence
import arrow.core.extensions.option.applicative.applicative
import arrow.core.some

                val eitherList: Either<*, List<*>> = listOf(Either.right("Foo")).sequence(Either.applicative())
                val optionList: Option<List<Int>> =
                    listOf(1.some(), 2.some(), 3.some())
                        .sequence(Option.applicative())

as

Type mismatch: inferred type is Kind<EitherPartialOf<Nothing> /* = Kind<ForEither, Nothing> */, Kind<ForListK, String>> but Either<*, List<*>> was expected

(I tried following this https://www.47deg.com/blog/traverse-typeclass-in-arrow/ and https://arrow-kt.io/docs/apidocs/arrow-core-data/arrow.typeclasses/-traverse/) I am on

arrow_version = '0.11.0'

. Also is there a stable

RC

of

v1

? (I need reliable builds) Or how big of breaking changes can I expect? Is there a document on this somewhere?

A PR was raised to make Arrow Fx Coroutines depend on KotlinX Coroutines to easy integration and usage since almost everyone has KotlinX Coroutines on the classpath anyway. More details in the PR Reviews and feedback welcome: https://github.com/arrow-kt/arrow-fx/pull/317

Hi again 👋

0.12.0-SNAPSHOT

is ready!

1.0.0-SNAPSHOT

will be deleted within 1 hour. Sorry for the inconveniences 🙏 See you!

A PR was raised to make Arrow Fx Coroutines depend on KotlinX Coroutines to easy integration and usage since almost everyone has KotlinX Coroutines on the classpath anyway. More details in the PR Reviews and feedback welcome: https://github.com/arrow-kt/arrow-fx/pull/317

I noticed a little discrepancy in deprecation of

ForkConnected

here it should be

ReplaceWith("async(ctx) { f() }", "kotlinx.coroutines.Deferred")

The thing is, signature of

async

is

CoroutineScope.async(ctx...

. But

ForkConnected

itself doesn't need

CoroutineScope

. Was this intended, or is it an oversight?

A tiny bit of topic, but I just noticed that @raulraja gave a talk about Kotlin computational blocks (i.e. delimited continuations) in the jlove conference. Is there any recording that exists of that talk at all? or like any other talk from the conference lol because I've been searching the internet and couldn't find anything

Hi all, is a recent run of https://github.com/arrow-kt/arrow-fx/tree/master/arrow-benchmarks-fx available anywhere? Failing that, does anybody know a) how to run it b) roughly how long it takes to run? I've not been able to run it, when I type

gradle jmh

with Java 14 in that dir gets me a

Caused by: javax.lang.model.type.UnknownTypeException: Unknown type: "none" at com.squareup.kotlinpoet.TypeName$Companion$get$1.visitNoType(TypeName.kt:187)

trying again with java 8, I get a compilation error :blob-shrug:

I really like the library (after reading the https://www.raywenderlich.com/9527-functional-programming-with-kotlin-and-arrow-getting-started series) The one unfortunate thing is that I must write as much as possible in common Kotlin. I saw that there was a struggle with implementing it in common, due to the annotation processor. The latest update in this slack (if I'm correct) is a possible solution. https://kotlinlang.slack.com/archives/C5UPMM0A0/p1603973285294900?thread_ts=1603566792.263600&cid=C5UPMM0A0 My question is: are there updates? Or even better, what is the place where I could follow those updates?

Hi, say I wanted to transform a property (or function) using kotlin-meta. Can I also find and transform all the places in a project where said property is used? (Like refactoring would do)

property(ctx, { ... }) { prop: KtProperty ->

    // now where is this property used?

    Transform.replace(
        replacing = prop,
        newDeclaration = ...
    )
}

Hi! Is there a pattern/best practice to parse arbitrary text into a Kotlin object? I currently have a

fun parse(List<String>): SomeDomainObject

That consists of many, many, many calls to

startsWith

and similar in an enormous

when

. The data I'm parsing was not designed to be parsed by a program, but to be read by humans, so there's no automated way (like Kotlinx.Serialization)... Is there anything in Arrow or any programming pattern that could help clean up this code so it's easier to maintain?

Hi! I see

ValidatedPartialOf

is deprecated, coz

Kind

is going away. Can someone please let me know how the below example will this be implemented in future. Thanks. https://arrow-kt.io/docs/next/patterns/error_handling/#example--alternative-validation-strategies-using-applicativeerror

so I was testing out the changes in 0.12.0-SNAPSHOT and had a question around syntax, in the following function:

suspend fun validateAndSave(a: RequestA): Either<Error, ModelA> = either {
    val validA = validate(a).bind()
    save(validA).bind()
}

would this be translated to the following and is that the expected route to take or is there some other syntacical sugar I can take advantage of?

suspend fun validateAndSave(a: RequestA): Either<Error, ModelA> = either {
    val validA = validate(a)()
    save(validA)()
}

and this

val result = either<Throwable, Int> {
    val allEmployees: List<Employee> = allEmployees()()
    val greetings: List<EmailMessage> = birthdayMessages(allEmployees, date)()
    val results: List<String> = greetings.parTraverseEither(<http://Dispatchers.IO|Dispatchers.IO>) {
        println("before")
        val greeting = sendGreeting(it)
        println("after")
        greeting
    }()
    results.map { println(it); 1 }.sum()
}

has no output before or after

Question about

sequence

. Is there a way to avoid 2 boilerplate `fix()`s in the below example to get that data type? Is there any on-going development on this, now that

Kind

is being deprecated?

val listOfOptionalNumbers: List<Either<Int, Int>> =
     listOf(1.right(), 2.right(),3.right())
val result: Either<Int, List<Int>> = 
     listOfOptionalNumbers.sequence(Either.applicative()).map { it.fix() }.fix()

If Arrow computations are based on suspending functions, how can I conceptually translate "a list of effectful actions" into this suspension-based system ? (like e.g. here https://wiki.haskell.org/IO_inside#Example:_a_list_of_I.2FO_actions) And if that question may be irrelevant or doesn't make sense here (or may even be trivial, because a list of functions can surely be created in Kotlin), I guess my underlying question is: What are the specific type-level- or runtime-level-guarantees (or advantages) in this style of computation ? What is nice and obvious is: datatypes (like Either), monadic binding blocks, concurrency-helpers (like parTraverse..., scheduler etc.), cancellation (but we get this anyway from kotlinx-coroutines, or?) But I think there is more to be said about this (and in a clearer way than I tried in an ad-hoc style here 😅), and I think if there is, it should definetly stand out in a to-be-created documentation of a new arrow-release. (just my 2 cents, but I think other prospective 'end-users' ... aka application developers... probably have similar questions.. ?)