I'm writing a library that I want to be cross compiled to iOS. I have a function type which returns an

Either

eg:

(Any) -> Either<A, B>

and I want Swift authors to be able to write functions that conform to that signature to be passed into functions in my library. That way I can delegate certain platform specific ideas to the platform. However I can't seem to be able to create an

Either

in Swift code. Looking in the MPP generated headers, I can see the

Arrow_coreEither

type with its methods (eg:

bimap

) but I can't find the

Right

or

Left

constructors. Is there something I have to do in my Kotlin project to expose the types properly? Has anyone done this successfully?

This is a bit pedantic maybe, but I was hoping people could share their opinion on how they name function parameters and types in a way where you don't unnecessarily repeat (or leave out) information.

NonEmptyList<A>

is an awesome data-structure, I reckon one of it’s use-cases can be as a param to force callers to pass non-empty lists. But any reason why there is no

NonEmptySet<A>

?

I'm looking through this example and wonder if Exception handling is intentionally omitted here (all the way down the stack)? My assumption is that the function is defined as

suspend

because it is making a network call (not pure), but I'm curious what would be the recommended approach to handling exceptions.

Does a book exist or video tutorials?

how can I return a raw value as the left value when inside an either block? E.g.

fun test() = either<String, SomeObject> {
    val someString = ""
    // how can I return 'someString' as the left value of this either?
}

given/using

was one of the biggest things I really missed compared to coding in Scala and now Kotlin essentially has it 😅

Hi, I am not able to see proper stacktrace and line numbers when a runtime exception is thrown in an

effect

block. I get something like

at foo.bar.BookService$bookReservation$suspendImpl$$inlined$invoke$1.invokeSuspend(Effect.kt:44) ~[main/:?]
at foo.bar.BookService$bookReservation$suspendImpl$$inlined$invoke$1.invoke(Effect.kt) ~[main/:?]
at foo.bar.BookService$bookReservation$suspendImpl$$inlined$invoke$1.invoke(Effect.kt) ~[main/:?]
at arrow.continuations.generic.SuspendMonadContinuation.startCoroutineUninterceptedOrReturn(SuspendingComputation.kt:89) ~[arrow-continuations-jvm-1.0.1.jar:?]
at arrow.continuations.Reset.suspended(Reset.kt:27) ~[arrow-continuations-jvm-1.0.1.jar:?]
at foo.bar.BookService.bookReservation$suspendImpl(BookService.kt:104) ~[main/:?]

Line number 104 does not even exist... Edit: Same as https://github.com/arrow-kt/arrow/issues/2647

hi, a friend of mine wrote the first article in a series about domain validation in Kotlin with Arrow [https://medium.com/@tibtof/domain-model-validation-in-kotlin-part-1-21fa44c60ef3]

Is there a better approach to this code?

// create a hash from clear password
return hashPassword(password, pbkdf2Values)
     // search for email/hash pair in db
    .flatMap { database.findUserByCredentials(email, it) }
    .map {
        // if user is registered, check for existing auth token 
        when (val existingToken = database.token(it, userAgent)) {   
            is Either.Left -> createToken(jwtValues, it, userAgent) // no token -> create a new one
            is Either.Right -> existingToken.value // token exists -> return it
        }
    }

I tried to use

either.eager{}

or

fold(ifLeft, ifRight)

but I didn’t find any solution more convincing 😕

Is it possible to modify an object by applying multiple `Lens`es in one turn? It causes lots of new object creation if I apply them sequentially...

Hi! Lately, I’ve been wondering how helpful Currying, Compose and Pipe are in the Kotlin FP world. is something that i should be using regularly as kotlin fp programmer? or is something more useful for programming languages like Haskell?

👋, i bring you another doubt, always thinking from the FP point of view, purity above all hehe

When will we have the

EffectScope<>

refactor available? I’m looking forward to trying it 😋

Hi iam trying to switch to Arrow exception handing within my current android application it appears to working ok up to now i would appreciate some advice on the following code is this a valid use of "`either {}`" with a single "`bind()`" containded within it? is there any "better" alternative?

val work: Either<DatasourceException, *> = either { persistOutcome().bind() }

is there something like

parZip

that just returns a

TupleN

?

I am looking into arrow analysis and it talks a bit about

require

being invariant, and pre/post conditions being something different.

fun increment(x: Int): Int {
    pre(x > 0) { "value must be positive" }
    return x + 1
}

fun increment2(x: Int): Int {
    require(x > 0) { "value must be positive" }
    return x + 1
}

But here both seem to work the same, and if I look into the code I see pre() is just calling require. If I then look at the examples in the documentation (https://arrow-kt.io/docs/meta/analysis/types/)class

Positive(val value: Int) {
  init { require(value > 0) }
}

and 

class Positive(val value: Int) {
  init { 
    pre(value > 0) { "value must be positive" }
    post({ this.value > 0 }) { "value is positive" }
  }
}

could the second example also be written

class Positive(val value: Int) {
  init { 
    require(value > 0) { "value must be positive" }
    post({ this.value > 0 }) { "value is positive" }
  }
}

and it being the same thing? or is there a difference between pre and require?

Hey new to Arrow here, using only Core so far and I got a question, probably a bit stylistic about how code looks like. I often find myself at the end of a chain where I got an

Either

to want to do something with the result, whether it’s left or right. 1. I see there’s one alternative of assigning the result to a value and doing a

when

on it, which works but feels a bit “extra”. 2. I can do a

tap

and a

tapLeft

which i don’t like because I’m doing it in two functions. 3. There is also

fold

which is what I am using the most, but this also comes with folding the two types into one which isn’t what I am looking to do in those scenarios. I would like to be able to have an alternative that does basically what tap/tapLeft does but for both cases. And now I wonder, does this not exist right now because: 1. It’s too easy to simply do our own implementation of it 2. No good name exists to denote such a behavior 3. It’s generally not a good idea and if I am looking to do something like this I probably want to do something else instead And I feel like the 3rd option is what’s happening here so I wanted to bring this up here to see what people generally do in those cases 🤔

Hey, i'm experimenting with Arrow Analysis, and I noticed something. I think I kinda guess why this works like this, but thought it would be interesting to share: I was trying to see how far I can take Arrow Analysis and I was writing a Spring Boot application and tried to see what happened if I used this as a

PathVariable

@RestController
class MyController {

    @JvmInline
    value class Positive(val value: Int) {
        init { require(value > 0) }

        operator fun plus(other : Positive) = Positive(this.value + other.value)
    }

    @GetMapping("/{id}")
    fun getTypeWithId(@PathVariable("id") id : Positive) : ResponseEntity<Positive>{
        println(id)
        return ResponseEntity.ok(id)
    }
}

Turns out, if I send a request with the value

-1

it will actually print and return

-1

, so I just managed to create a Positive negative value 😄 So it compiles, and it seems that jackson is ignoring the

require

when creating a value class. (I am aware that this is not Arrows fault, just wanted to share)

Does anyone have experience with

ReplaceWith

? https://kotlinlang.slack.com/archives/C0B8H786P/p1646749747028839

I feel like a bit of a n00b because I find the Monoid docs not really helpful in understanding how to use Monoids in Arrow (I use them regularly in other FP programs). I have a

List<Map<String, String>>

and I want to fold it down to

Map<String, String>

. How could I do this using a Monoid in Arrow?

https://kotlinlang.slack.com/archives/C5UPMM0A0/p1646811136681089?thread_ts=1646787156.669429&cid=C5UPMM0A0

Iterable::combineAll

looks to be the same as

Iterable::fold

or am I missing something?

Currently using something like

fun onSomethingChecked(isTrue: Boolean, onTrue: () -> Unit, onFalse: () -> Unit) {...}

Option<Unit>

seems like a better option than

Either

I'm testing https://arrow-kt.io/docs/meta/analysis/ but it has some blocking errors for our projects: https://github.com/arrow-kt/arrow-meta/issues/1031 https://github.com/arrow-kt/arrow-meta/issues/1032

hey, quick question: I have just been pointed towards the (haskell) concepts of "SYB/uniplate/Control.Lens.Plated" to use instead of the typical visitor pattern for rewriting abstract syntax trees. Does Arrow have anything in that direction already? Arrow has something called

Lens

as part of the

Optics

component, but I don't know if this is the same idea, and because I am not familiar with those concepts already, I'd rather focus on learning and understanding the thing I actually need for my project, not something else that happens to have the same name 😅

I'm playing with Arrow Analysis (AA). It seems like

require

is treated differently by the compiler compared with a project that doesn't use AA. Is this a correct observation? For example, this, which doesn't explicitly use any AA features,

fun fn() {
    val x = 1
    require(x == 1)
}

results in a compiler error:

could not parse predicate: x == 1

Whereas in a project without AA, there's no compiler error.

where you can have something like

Option<String?>

Is there a nice way to map an either through a lambda that might throw and catch/map the exception to left? At the moment I have

fetch(key).flatMap { Either.catch({ Malformed(key) }) { f(it) } }