I wonder what the Arrow team is planning, however. I split the Functor interface into 2 btw because I originally had a version with the normal Functor interface but it then required an

@with

decorator for each pair of ins-and-outs, as in you'd need all of an

@with(optionFunctor<Int, String>())

, an

@with(optionFunctor<String, String>())

, an

@with(optionFunctor<Unit, String>())

, and an

@with(optionFunctor<Any, String>())

in the above example to make it work, and that multiples massively for each different type of input or output that you need to include, while with the splitting you only need to have a decorator for the sum of the number of inputs and outputs that you have. I think that probably having a huge amount of decorators will make the code look ugly even if it was generated automatically by the IDE, but I still have that original code if needed. Hopefully though you guys have already made a much much better encoding than this horrendous mess lol.

Pretty new to both Arrow and functional programming, so excuse my confusion beforehand. 🙂 I have working code like the following:

either {
  val id = parse(info).bind()
  val result = fetch(id).bind()
  Either.catch { ... }.mapLeft { ... }
}

And I am trying to get MDC logging to propagate through all of these calls. But it seems Arrow is dispatching on a new CoroutineContext so the MDCContext() in the original context is not propagated. Any pointers as to how I can get this to run with the "parent" context? IO.unsafeRunScoped seems relevant but not applicable... 🙂

If understanding this (0.12 !) documentation correctly, there is no recommended special (arrow) coroutine builder for starting (for example) an either computation ? https://github.com/arrow-kt/arrow/blob/master/arrow-site/docs/docs/fx/README.md#executing-effectful-programs

Thinking of the Monad instance of List, will there be such computation in arrow 0.12 (list comprehension) ?

@simon.vergauwen I'd suggest replacing

validated { }

with something that takes a varargs of

Validated

values

i have a little issue

Duplicate class arrow.core.ListKt found in modules arrow-core-data-0.12.0-SNAPSHOT (io.arrow-kt:arrow-core-data:0.12.0-SNAPSHOT:20210318.205637-108) and arrow-syntax-0.12.0-SNAPSHOT (io.arrow-kt:arrow-syntax:0.12.0-SNAPSHOT:20210318.205637-105)

Result keep got updated https://github.com/Kotlin/KEEP/pull/244

Hi everyone, I'm looking for inspiration. Do you know of any open-source app written with Arrow? I've found a few, but they are more proof-of-concepts/prototypes than actual apps

What is the current state of Arrow for multiplatform?

^^^ I do understand the concept of instantiating an IO, building it up, and finally "running" it does that mean that, in the context of a jersey endpoint, it would have to look like this?

class UserResource (private val userDao: UserDao) {

  @POST
  fun post(CreateUserRequest createUserRequest){
    return IO
      .fx {
        userDao.create()
    }
  }.runUnsafe something something
  .toEither()
  .fold({ left ->
    Response.serverError()
  },{ right ->
    Response.success(right)
  })
}

I really enjoyed this presentation on YouTube and very interested in Arrow, but a scared off by some recent “Functional Programming” elitism I have seen in the Scala community. 1/ I really like type classes (I learned about them from tooling around in Haskell) and most of my substantial systems in the last ten years could have made good use of them. It’s generally a good idea to include them as part of the language (both Kotlin and Scala). 2/ I did write two 50,000+ line systems (server-side JVM), each with immutable models only. I did use shallow trait inheritance. I also used Akka Actors, each actor with a single var, for concurrency. (This was before typed actors.) All substantial business logic was part of the immutable classes. I thought I was doing functional programming in the immutable parts of the code (almost all of it) even without a library like Arrow or ScalaZ. My point is that functional programming is larger than and pre-dates category theory-style libraries. Before Scala I also wrote substantial systems in Standard ML, Common Lisp, and quite a lot of functional Scheme. Immutable and first class functions are good for programming even if not done with higher kinded types! 3/ I really worry that some Scala FP people, in pushing purity (puritanism?) have not convinced and tried to bring along the rest of the programming community by showing that these techniques are useful in context, but instead tried to look for converts who would reject prior learning and experience. I think this is a huge mistake and harmful not only to language communities but also turns many programmers away from what FP has to offer. It becomes more of an esoteric society than a useful way of writing systems. 4/ Programming languages and programming styles are tools for human being to think with. The only relevant question is do they help human beings think about and solve problems and communicate ideas to others. I’ve seen clean, easily understood FP programs and just as good OOP programs. I’ve seen really bad FP and OOP programs! We need to face that there are some domains that FP does not handle well even though many people have tried. Real world simulation models are still much better expressed as OOP (or mixed FP/OOP). Pure FP code for complex UI programming is really much harder to understand. (And yes, React is very impure in case you are wondering.) I like Kotlin a lot, including it’s embrace of multi-paradigm development. I hope Arrow can leave dogmatism at the door and ask more where can FP convincingly embraced as useful. It is important be willing to accept that FP is not the final programming paradigm and may not always be the best choice for actual human developers. 5/ How can you write substantial FP applications without functional (persistent) data structures? I’d imagine the alternative is to do a whole lot of copying and use much more memory for lack of shared data. I was pretty shocked that a good package of functional data types was not a key part of Arrow, or perhaps my impression is out of date? Can anyone recommend a library? Thanks!

There's something I don't quiet understand, coroutines are an implementation of the Continuation monad, right? Then why is it recommended to use them instead of the IO monad?

IO and suspend questions are so hot right now Thanks to the excellent reply to my previous question and reading around a bit more, I now feel like I understand IO/suspend better in practice But even as someone who's very fond of FP, I must admit I struggle to see the point a bit Like yes you can construct computations and map and filter and chain etc them in weird and wonderful ways but what's the practical actual use? I can make a strong case to FP skeptics for not using null, using result types instead of exceptions etc But I'd REALLY struggle to make any case at all for just coding vs creating an object of code and then calling .run

Good morning, regarding

Either

, which is the best way to get left? Example

// ok
assertEquals(expectedResult, either.orNull())

// how?
assertEquals(expectedError, either.<leftOrNull()>)

I am trying to learn FP using the Manning MEAP book Functional Programming in Kotlin. There is one exercise for which no answer is provided that I have a solution but it kind of seems yucky to me. How might an experienced FP Kotlin developer solve this:

Hello Team, I am new to Arrow library. Have a question on 

arrow.fx.coroutines.Schedule

  . Is there a way to get the number of attempt in the Either.catch

Either.catch{
	retry(Schedule.exponential(250.milliseconds)) {
		evalOn(IOPool) {
			//do something
	  		incrementMetricSuccess(attempt)   -------> want to increment metric with the attempt it got successful
		}
	}
}.mapLeft {
	incrementMetricSuccess(attempt)    -------> want to increment metric with the attempt to fail
}

Hi, I have just noticed that

.curried

extension functions on functions is deprecated. Is there any replacement for that? I was using that method for

dependency injection

for functions. I assumed that

currying

is a basic operation in FP. Why it is being removed?

also 0.13.0?

There seems to be a bug in optics generation in 0.13.0. it generates

AppState(tuple.a, tuple.b, tuple.c, tuple.d, tuple.e)

but Tuple5 doesn't have a, b, c... props anymore. it has first, second third... Is this just "we are in the middle of release, so things don't yet line up", or is it bug that slipped through?

Not directly Arrow related, but someone might have had a similar issue. I’ve been switching our effectful functions over to

suspend fun

, but a library we use (

java-dataloader

) requires functions with a CompletableFuture return type. How have folks been switching between

CompletableFutures

and

suspend

?

this doesn’t work :

val (a: A, b: B) = parZip({ funA() }, { funB() }, ::Pair)

but this works :

val (a: A, b: B) = parZip({ funA() }, { funB() }) { a, b -> a to b }

in v0.13.0

This fails in

v0.13.0

private fun methodThatThrows(): Either<Throwable, Unit> = Either.catch { throw CancellationException("") }

@Test
fun `test parTraverse`(): Unit = runBlocking {
    val result: Either<Throwable, Unit> = either {
        (1..20).parTraverse { methodThatThrows().bind() }
    }

    result shouldBe CancellationException("").left()
}

I cannot reach assertion, and throws as soon as

methodThatThrows

is called. cc: @simon.vergauwen (Sorry for tagging you on easter vacation, just want to make you aware 🙂 )

0.13

doesn't appear to have a

Tuple3

. Tuples start at

Tuple4

. Is this correct?

I'm upgrading from 0.11 to 0.13. Is there an updated document on traverse?

Here is the release post on 0.12 - 0.13.1. Thanks to everyone who contributed. @simon.vergauwen has detailed all the changes and migration guide here: https://www.47deg.com/blog/arrow-0.13.0-release/

The migration guide is very well written, thanks a lot ^^ I understand that higher kinded types are being removed because their integration in Kotlin is far from perfect, but do you think that decision is going to stand or are you thinking of reintroducing them sometime in the future when the language has changed to fit them better (eg. Arrow Meta, multiple receivers...)?

I’m having trouble continuing to use the

Reader

type after upgrading to 0.12.0. (MTL is still on 0.11.0 though). After this upgrade:

-  val arrowFx = "io.arrow-kt:arrow-fx:0.10.5"
-  val arrowMtlData = "io.arrow-kt:arrow-mtl-data:0.10.5"
-  val arrowOptics = "io.arrow-kt:arrow-optics:0.10.5"
+  val arrowFx = "io.arrow-kt:arrow-fx:0.12.0"
+  val arrowMtlData = "io.arrow-kt:arrow-mtl-data:0.11.0"
+  val arrowOptics = "io.arrow-kt:arrow-optics:0.12.0"

I find that

reader.run(thing).value()

is no longer able to resolve

.value()

. How should it read now?

.run(thing)

is returning type

Kind<ForId, T>

--- Another migration question… With IO gone, how can I replicate this IO retry functionality?

fun <T> IO<T>.retry(
  until: (T) -> Boolean = { true },
  additionalTimes: Int = 4,
  initialDelay: Duration = 500.milliseconds
): IO<T> {
  val schedule = Schedule
    .withMonad(IO.monad()) {
      exponential<Either<Throwable, T>>(initialDelay)
        .untilInput<Either<Throwable, T>> { it.exists(until) }
        .and(recurs(additionalTimes))
        .jittered(IO.monadDefer())
        .zipRight(identity())
    }
  return map<Either<Throwable, T>> { it.right() }
    .handleError { it.left() }
    .repeat(IO.concurrent(dispatchers()), schedule).fix()
    .flatMap {
      it.fold({ throwable -> IO.raiseError(throwable) }, { t -> IO.just(t) })
    }
}

Hi, I've seen the new changes for 0.12.0 and

Either.catch

with

suspend

functions is deprecated and the inline one is not accepting them. How should it be done with this new version?