hi all! maybe cc @Imran/Malic any chances we can also bump https://github.com/arrow-kt/arrow-integrations/issues to 1.x in the next release cycle?

@Imran/Malic i’ve found a pretty embarassing bug in arrow-integrations-jackson-module - seems like that’s released for java 15 source compatibility. it works on maven but fails on gradle. 😭 https://github.com/arrow-kt/arrow-integrations/pull/93

hi @Imran/Malic i’m wondering if we can release arrow integrations for 0.14.0? we have just gotten the kotlin 1.7.0 changes merged

Some kind words to all contributors of Arrow by Sebastian. 🥰 Thanks all of you for being part of this awesome OSS community ❤️ https://twitter.com/sebi_io/status/1551490700742692864?s=20&t=ysx9Rea6aGjpsRTAnyO_mg

dear Arrow contributors: we’ve started planning Arrow 2.0 in this PR -> https://github.com/arrow-kt/arrow/pull/2778 it’s the moment of simplifying and improving our APIs! feel free to propose new ideas and breaking changes, we’ve already gathered some we plan to work on in that list of course, work on the main branch goes on, for both bug fixing and improvements which are API-compatible with the 1.x series

I can't seem to find the gradle task

spotlessApply

, is there a different way to do code-formatting now?

Phew this was a tough one, but I finally made a draft PR with a working implementation of a

value class Option

! Turns out while the compiler is very finicky and picky with its optimizations for value classes, it did still surprise me by being more optimized that expected. It's still missing tests, documentation, and benchmarks, which I will add in the next couple of days. The implementation does have some downsides though, so I wonder what the team thinks of it. Check it out here: https://github.com/arrow-kt/arrow/pull/2780

Hey @raulraja, I did a talk at a conference and they gave me an Open-Collective credit of $100, which I can use to Sponsor my favourite open source project. Arrow of-course comes to my mind first, this library and community helped me learn a lot. So I asked if there is an Open-Collective for Arrow to contribute. Thanks!

I am trying my hand at this issue: https://github.com/arrow-kt/arrow/issues/2812 but I am having trouble compiling the core module:

Deprecated Gradle features were used in this build, making it incompatible with Gradle 8.0.

is there a suggested gradle version?

Hello, anyone here with Windows who can try to reproduce this error? Unit test fails in NetworkEitherCallAdapterTest.kt:159 because of wrong exception type.

The issue that makes Gradle flaky in Arrow should be fixed in Gradle 7.6 🥳 https://github.com/gradle/gradle/issues/19446#event-7377915648

I was surprised the new

Resource<A>.allocated()

extension returns

Pair<suspend () -> A, suspend(A, ExitCase) -> Unit>

rather than

Pair<A, suspend (ExitCase) -> Unit>

. Much like in

cats.effect.Resource

I would expect

allocated

to actually allocate/acquire the resource (and provide the release).

I wondered if there was a way to have the resource bound the to lifecycle of the calling

CoroutineScope

to avoid any leaked resources if the finaliser isn’t called. I’m not sure if this is entirely safe wrt structured concurrency but it passes some rudimentary tests (and finalizer is called within the current context):

context(CoroutineScope)
suspend fun <A> Resource<A>.bind(): Pair<A, suspend () -> Unit> =
    allocate().let { (acquired, release) ->
        acquired to guaranteeCase(release)
    }

fun CoroutineScope.guaranteeCase(finalizer: suspend (ExitCase) -> Unit): suspend () -> Unit {
    val completion = CompletableDeferred<Unit>()
    val finalize = async(NonCancellable) { guaranteeCase(completion::await, finalizer) }
    val hookHandle = coroutineContext.job.invokeOnCompletion {
        if (it != null) completion.completeExceptionally(it)
        else completion.complete(Unit)
    }
    return {
        hookHandle.dispose()
        completion.complete(Unit)
        finalize.await()
    }
}

or alternatively without the

CoroutineScope

receiver/context (but requiring a current

Job

)

suspend fun <A> Resource<A>.bind(): Pair<A, suspend () -> Unit> =
    allocate().let { (acquired, release) ->
        acquired to guaranteeCase(release)
    }

suspend fun guaranteeCase(finalizer: suspend (ExitCase) -> Unit): suspend () -> Unit {
    val completion = CompletableDeferred<Unit>()
    val finalize = async(NonCancellable) { guaranteeCase(completion::await, finalizer) }
    val hookHandle = coroutineContext.job.invokeOnCompletion {
        if (it != null) completion.completeExceptionally(it)
        else completion.complete(Unit)
    }
    return {
        hookHandle.dispose()
        completion.complete(Unit)
        finalize.await()
    }
}

private suspend fun async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
) = Job(coroutineContext.job).let { job ->
    CoroutineScope(coroutineContext + job)
        .async(context, start, block)
        .also { job.complete() }
}

hey all... any plans to de-couple the release of arrow-optics (especially the ksp compiler plugin) from the rest of arrow and do more frequent releases? asking because ksp is tied to specific compiler version.... and that is a direction some projects (e.g. compose) are taking

Hey everyone, I'm looking for some feedback on some new APIs. All details are inside the PRs. Tracing POC, Add Atomic module, and StateShift, and Rename Shift to Raise according to Slack Poll, and add some initial docs. I know the last one is/was a bit controversial, and there were many interesting opinions. I've listed some additional argumentation, and rephrased the documentation a bit. Hope it makes more sense this way to everyone. (cc\\ @phldavies)

Hello all, I have a one-liner PR which changes the expected type in one of the

arrow-core-retrofit

tests to a more general one (because apparently the more specific type made the tests fail for some OS/JVM combinations when building locally). It just needs one more approving review, it would be awesome if someone could take a look: https://github.com/arrow-kt/arrow/pull/2822

Hello, I have had this PR open for a while and I really want to close it but I want some input. The current implementation might not be optimal but it does preserve the laziness of the sequence and the one I provided actually breaks that. I thought about this quite a bit and I feel like the best choice is to replace the

flatMap

with a

filter

, if that provides any benefits at all. I'd love to hear your thoughts https://github.com/arrow-kt/arrow/pull/2818

hi friends.. I’m asking for some help. I’m hoping if arrow is able to release arrow-integrations to 0.14.0. (I know I asked this a few months back so sorry for the noise). This is the repo https://github.com/arrow-kt/arrow-integrations. Would anyone in the team be able to help? Additionally if someone can teach this man how to fish, I’ll also be more than happy to manage releases for this repo so that I don’t have to hassle the team too much. Thanks in advance!

your feedback is more than welcome in a few discussions: • simplifying the optics hierarchy https://github.com/arrow-kt/arrow/discussions/2859 • the right function for

Iterable<Either<E, A>>

https://github.com/arrow-kt/arrow/discussions/2861

we’ve spent a bit of time tagging a few Arrow issues as beginner friendly https://github.com/arrow-kt/arrow/issues?q=is%3Aissue+is%3Aopen+label%3A%22beginner+friendly%22 as usual, if you want to contribute, feel free to write in this channel for any help you may need 😊

I'd like to give issue 2821 a shot. Does someone else need to assign it to me? I don't have assignment rights on the repo.

I'm working on changes in

arrow-fx-coroutines

. But I always get

Cannot find declaration to go to

when I try to navigate to a symbol's declaration in IntelliJ. I'm wondering if I set up the project incorrectly. I imported the

build.gradle.kts

that's in the root directory

arrow

into IntelliJ. Should I have done something different? In IntelliJ, I'm also getting compiler errors in

DeadlockTest.kt

,

EitherJvmTest.kt

,

EvalJvmTest.kt

,

NonFatalJvmTest.kt

, and

JvmGenerators.kt

. These are the ones in

DeadlockTest.kt

, for example:

/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:16:15
Kotlin: Unresolved reference: Validated
/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:18:15
Kotlin: Unresolved reference: Validated
/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:30:15
Kotlin: Unresolved reference: Either
/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:32:15
Kotlin: Unresolved reference: Either
/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:44:15
Kotlin: Unresolved reference: None
/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:46:15
Kotlin: Unresolved reference: Some
/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:58:15
Kotlin: Unresolved reference: Ior
/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:60:15
Kotlin: Unresolved reference: Ior
/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:72:15
Kotlin: Unresolved reference: Eval
/Users/bayo/dev/arrow_fork_3/arrow-libs/core/arrow-core/src/jvmTest/java/arrow/core/DeadlockTest.kt:74:15
Kotlin: Unresolved reference: Eval

Any suggestions on how to get IntelliJ to behave correctly? I'm flying blind without IDE support as I make changes. Thanks!

I followed

CONTRIBUTING.md

to run

./gradlew spotlessApply

, but got the error

Task 'spotlessApply' not found in root project 'arrow'

. I found this in a year-old PR. How do others handle this error?

Is there a preference for PRs to be a single commit?

CONTRIBUTING.md

doesn't appear opinionated about this.

I updated a PR, which triggered a build. Though the build succeeded when I ran it locally, Github reports it failed on the

check

step. I examined the log, but didn't find any failure. Could it be that it timed out? That step took 50 minutes. Is there a way to trigger a build manually, without changing branch history? Thanks!

For issue #2894, I found these tests for

curried

. May I use them as a pattern for the

curried

functions that are missing tests? Is there anything that should be done differently? Any other considerations that are undocumented? I think I'll remove the

curried

tests from

FunctionSyntaxTest.kt

and add a new file with just

curried

tests. That sound reasonable? Thanks!

@raulraja @simon.vergauwen Is there a consensus to kill #2821, or is further discussion needed?

For anyone here working on OSS, or contributing to Arrow. If you have some feedback for the Kotlin team on library development. https://surveys.jetbrains.com/s3/kotlin-libs-authors-survey

Just a heads-up that, in order to support testing Arrow functions with arity greater than 12, I contributed a PR to the Kotest project. The PR has been merged into

master

, and should be released, according to @sam, next in v5.6. With it,

checkAll

,

forAll

, and

forNone

will support up to 22-arity.