Also, we are using Arrow in Spring and a hexagonal (Ports&Adapters) Architecture and I'm really wondering, where we best draw the line between "Here Spring gouverns dependency injection" and "Here we do DI the Arrow way (with receivers)". Currently our team is leaning towards "Use Spring everywhere down to the service layer" but I would be very interested if someone already has some experience with this..?

Hi! I'm starting to use arrow for data validation (I'm not super familiar with the library, but I used cats/scalaz libraries for scala in the past). Following the docs about Validated I noticed that this snippet doesn't compile

data class Config(val map: Map<String, String>) {
  suspend fun <A> parse(read: Read<A>, key: String) = either<ConfigError, A> {
    val value = Validated.fromNullable(map[key]) {
      ConfigError.MissingConfig(key)
    }.bind()
    val readVal = Validated.fromNullable(read.read(value)) {
      ConfigError.ParseConfig(key)
    }.bind()
    readVal
  }

In particular I wasn't able to call

bind()

from a

Validated

. Is that something I am missing? Also I noticed that

bind()

is not listed among the functions for

Validated

in the docs. I'm using

arrow-core version 0.11.0

Hi! I’m playing around with refined types and anticipated intellij to show me the red squiggly line whenever providing illegal constant value as an argument to invoke function, but the ide doesn’t really show me an error only in console when building the project. I’m working at 2021.1.2 version of intellij. Can I do something about it?

is it omitted on the docs for simplicity or there is a workaround to not declare it ?

Not an arrow question per se, but is there a way to have a function return a function with a generic type in Kotlin/Arrow. I want to do

fun doSomething(): ((Class<T>) -> T) -> T

However because lambda expressions can't have generic types, this doesn't compile for me.

Hi, is there a way to call suspend function inside

eval's

map and flatmap. I have this code but it doesn't compile as

doSomething()

can only be called withing coroutine body.

import arrow.core.Eval
import kotlinx.coroutines.runBlocking

fun main(): Unit = runBlocking {
    Eval.now(10)
        .map { doSomething() }
        .value()
}

private suspend fun doSomething(): Int {
    println("do something")
    return 20
}

Hola!!. I have a question regarding arrow upgrade to 0.13.1

Hi 👋 . What is the proper way to get a list of errors

List<Error>

out of

List<Either<Error, Result>>

?

Sorry for the basic question. Given I have a list of identifiers

val ids = listOf(1, 2, 3)

and I have a function that returns a valid thing for a given identifier

fun getThing(id: String) : Either<String, Thing?>

what is the best way to execute the getThing function for all ids in the list until a Thing is found, or an either.left is encountered? Traverse is close to what I need, but it will involve unnecessary database calls; I will like to exit processing as soon as a match is found.

What method should be used to perform a side-effect using the value of the left side of an

Either

? I could use

fold

. But that doesn't seem quite right since

fold

`s intent seems to be more on producing a value, not performing side-effects.

How will Context Receivers (https://github.com/Kotlin/KEEP/blob/context-receivers/proposals/context-receivers.md) impact Arrow? In particular, they mention Monoid as a use case, and that looks really close to what typeclasses were trying to achieve

I tried arrow refined-types and I wonder if there is a way to combine them with Validated from the core library

Hello! I'm trying to understand how to mark side effects correctly. Documentation to Arrow Fx describes using

suspend () -> A

instead of

IO<A>

. Does this literally means that signature of the function that produces a side-effect should be

suspend () -> A

, or it can be

suspend (parameter1, parameter2...) -> A

? Which one is correct and why:

data class Message(val content: String)
suspend fun sideEffectProducer(message: Message) = println(message)

or

data class Message(val content: String)
suspend fun Message.sideEffectProducer() = println(this)

And a follow-up question - how functions with side effects differ from pure functions that use

either

block and

.bind()

results? Both of them are

suspend

when i see the photo profile i think that someone was impersonating Simon

Hahaha, ye I guess I have to win everyone’s trust again looking like a total stranger 😂

Hello! Is there a reason why I should write my code using extension functions, not regular member ones? I understand that they are resolved in compile-time, is this it? Extension functions allow the compiler to build and optimise the whole flow rather than treat the code as a set of objects that can interact with each other? Or is it just a question of style?

hi - wondering if

either

lazy blocks do not play well with the coroutine dump generator? i use (the scarcely documented) way of sending a process a 5 signal to get a coroutine dump (similar to 3 for a thread dump) … the line numbers often don’t make sense (larger than the file contains, refers to desugared code?). in every case i believe the coroutine is suspended somewhere within the

either

block (though hard to be 100% sure given the line number inaccuracy) the top of the coroutine stack frames is always the function containing the

either

block, i was hoping to see more detail

Hello 🙂 I am trying to understand a bit how to use

either

with coroutines in Springboot and I am not sure I fully understand what’s happening. Take for example this code:

suspend myServiceFunction() = either {
  val r1 = someApiCall(...).bind() 
    // Either<Fail,Res1>
  val r2 = someOtherApiCall(...).bind()
    // Either<Fail,Res2>

  combineOperation(r1, r2) // Either<Fail, Res2>
}

My question is the following: how can we best make

someApiCall

and

someOtherApiCall

run in parallel? Is the

bind

for obtaining

r2

is waiting for

r1

to first get returned? Thanks 🙂

hi! I've wondered if the optics library can be implemented with a compiler plugin instead of actual code generation. If this was possible, what pros and cons have over the current implementation

can somebody link me real world example of using arrow and functional programming? not something that just uses

Either

and calls itself functional programming nor something too complicated for purposes of showing theory in practice.

Hi, afaik one only needs to use Environment() for unlocking Arrow FX Coroutines, if there's no suspended entry point in the environment. Ktor and Spring Boot are supposed to have such, but I don't find any suspended router functions. Do I have to rely on the fancy banner saying "Co-Routines included!" to decide, if I need to use Environment() or not, or am I missing something? 🤔

Hello, in the code below I'm expecting

.getOrHandle

to return

List<ContractorTas>

, however compiler thinks there is

List<Any>

. What am I doing wrong?

I did some work on the Arrow Fx docs, and wrote/improved some parts. In case any is interested, feedback is also welcome ofc 🙂 https://github.com/arrow-kt/arrow/pull/2460/files

Hello, Is there a function to combine two validated variable to check is they are compatible with each other Maybe a function like this to allow some check with both values

Validated<ValidationError, Enum1>, Validated<ValidationError, Enum2> -> Validated<Nel<ValidationError>, Pair<Enum1, Enum2>>

hi - i’m wondering why

Either.catch

is strict in evaluating it’s supplied function, is there a way to catch an Exception from an effect? eg

suspend findThing(): Thing {} 

Either.catch { findThing() } // ???

I've turned back-end responses into

Either

monad from

Retrofit

interfaces. What do you think I've recently got from my partner? Brilliant idea: to skip handling each

Left

and just throw Exceptions. Remember the song?: lonelyyyy, I'm sooo loonelyyyy 😭

Hello everyone, I'm thinking of a project, main idea is about processing an image with

OpenCV

. I believe that I should implement something reactive + FP: imagine there is a bar where we can "just add new processing operation". This will result in a "list of operations", applied:

rawImage -> op1-> op2 -> op3 -> processedImage

. where all

opX

take result of the previous one. That would be great to memoize the result of operations, so that if I change some characteristics in

op3

for example (each operation has its own arguments), that wouldn't lead to recomputation of

op1

and

op2

. Which way should I dig in, how do you think? I think this is ideal for FP, what do you say?

Is there a book for Arrow?