I am building an app maximizing my Arrow usage to try and learn how to use it. I start with an

IO { File("/path/to…").walk()) }

and apply IO transforms to the sequence to end up with an

IO<Sequence<IO<Foo>>>

and then use

flatMap

and

sequence

to transform it to

IO<Sequence<Foo>>

. When I

unsafeRunSync

the result, I get a

StackOverflowError

, presumably from the part where I “lift” the nested IO out of the Sequence (has to iterate over all the elements in the sequence I think). Given that you’re ideally going to have a single place at the “edge” to run the IO, is there a better way I should structure it? Assume I’m starting with

IO<Sequence<IO<Foo>>>

and can do whatever to it. Is

myIO.unsafeRunSync().forEach { it.unsafeRunSync() }

the way I should go about doing it at the edge? Basically run the top-level IO to get the

Sequence

and then start taking values, whcih are themselves

IO

, and run them? Here is a simplified version of what I have now:

fun buildFoo(file: File): IO<String> = IO { "test" }
val program: IO<Sequence<File>> = IO { File("/Users/kylegoetz/Desktop").walk() }
val transformedProgram: IO<Sequence<IO<String>>> = program.map {
    it.map {
        buildFoo(it)
    }
}
val noNestedIO: IO<Sequence<String>> = transformedProgram.flatMap {
    it.filterNotNull().k().sequence(IO.applicative()).fix()
}

noNestedIO.unsafeRunSync() // StackOverflowError

A solution is a lazy version of

ap

(it's actually solution to many many more problems 🙈 ) with that we would instantly return from

traverse

and execute/bind the

IO

as we go

not because it’s the practical thing to do, but because it gives me a reason to learn more about FP

does this syntactic sugar live in Arrow-kt by a named concept i can study up? it looks as close as i can make to the cat theory chalkboards lectures of f follows g

operator fun <A, B, C> Function1<A, B>.times(r: Function1<B, C>): (A) -> C = { x: A -> x.let(this).let(r) }

demonstrated below with the _***_'s

val bb2ba: (ByteBuffer) -> ByteArray = { bb: ByteBuffer -> ByteArray(bb.remaining()).also { bb[it] } }
val btoa: (ByteArray) -> String = { ba: ByteArray -> String(ba, Charsets.UTF_8) }
val trim: (String)->String  = String::trim
enum class TypeMemento(val bytes: Int?, val read: readfn, val write: writefn) { 
    txtInt(4, (bb2ba * btoa * trim * String::toInt), { a: ByteBuffer, b: Int? -> a.putInt(b ?: 0) } as writefn),

The new look of arrow-kt.io is amazing 🤩

Excellent first issue for someone wanting to understand error handling in FP. Review and update the error handling tutorial to use friendlier models that are not war related. https://github.com/arrow-kt/arrow/issues/1873

anyone experienced

arrow/core/Continuation
java.lang.NoClassDefFoundError: arrow/core/Continuation

in tests

Worked through https://www.pacoworks.com/2019/12/15/kotlin-coroutines-with-arrow-fx/ and tried to give it a shot on Android with Room (works great!) - however, I cannot get the

Promise

to mimic the view model lifecycle callback (as described at the end of the post):

val endPromise: Promise<ForIO, Unit> = Promise.unsafeUncancelable(IO.async()).fix()

simply does not compile. Same for

endPromise.complete(Unit).unsafeRunAsync { }

accordigly.

fix()

/

unsafeRunAsync

are simply not availble on the

Promise

instance. Any ideas?

Is there a benefit for using

Option<>

types over

Nullable?

types other than the syntactic difference?

You can define

typealias Bla = suspend (In) -> Out

what would be the way to log the exception (just log, do nothing to recover the failure) in case an

IO

fails?

Hey guys. I was thinking, is there a point in adding something like http://hackage.haskell.org/package/base-4.12.0.0/docs/Control-Category.html to Arrow? I just had a case where I had to generate a free poset by hand to encode some business rules, and intuition tells me that I could derive a lot more from it, but I can't get my mind around it yet. Thoughts?

IntelliJ warns me of an inappropriate blocking method call on

ImageIO.read

here. I understand it probably wants me to put this in a suspend fn and it’s just a linting thing. But since it’s in an

IO.fx

and has

!bind

wrapped around it, I should ignore this linting warning, right? That’s part of the point of IO and !effect, right?

fun imageReader(file: File): IO<Either<Throwable, ByteArray>> = IO.fx {
    with(!effect { ImageIO.read(file) }) {
        val argbArray = getRGB(0,0, width, height,null,0, width)
        val buffer = java.nio.ByteBuffer.allocate(4*argbArray.size)
        argbArray.forEach { buffer.putInt(it) }
        buffer.flip()
        buffer.array().slice(0 until argbArray.size*4).toByteArray()
    }
}.attempt()

Or should I be shoving this !effect into some other thread/dispatcher/process like one might in Android with

launch(<http://Dispatchers.IO|Dispatchers.IO>)

or something? (This is a Kotlin command line program I’m working on)

@marc0der Who do I talk to at Manning to suggest the time has come for a Kotlin version of Functional and Reactive Domain Modeling? I’m up to chapter 4 and neck-deep in trying to understand Scala implicits in order to in turn understand the code samples. A high price to pay for an Android developer whose interest is keenly in FP, definitely not Scala-FP. Implicits are easy to understand at a high level and in principle. But what a mess to understand when used.

just solved the Birthday Kata with Arrow, if anyone has the time to take a look, any feedback is appreciated, thanks -> https://github.com/LordRaydenMK/BirthdayKata

The new arrow site is incredibly sexy, my compliments to the designer(s) ❤️

What would be a good name for a union of Loading, Success, Error?

I want to execute a list of of

IO

actions all together with one call to

unsafeRunSync

. I know in Haskell there is

sequence

- is there a similar construct in Arrow?

I'm looking into combining Arrow (possibly Fx?) with JetBrains Exposed library. Any resources or best practices/recommendations around this? I've found this, but not sure what state it's currently in: https://github.com/codebandits/beak

I'm also trying to integrate with Ktor, but it seems a little difficult to get Ktor to play nicely with Arrow types. Fairly new to this though, so I might be missing something...

Thanks that worked…

Hello, I am trying to compose my program using arrow-fx with suspend functions instead of IO. Is there a possiblity to bind() suspend functions in Either.fx block? Like this:

object BusinessError
    object User
    object UserProfile

    suspend fun findUserByName(name : String) : Either<BusinessError, User> = TODO()
    suspend fun getUserProfile(user: User) : Either<BusinessError, UserProfile> = TODO()

    suspend fun getUserProfile(name : String) : Either<BusinessError, UserProfile> = Either.fx {
        val user = findUserByName(name).bind()
        getUserProfile(user).bind()
    }

I’m struggling to understand how to replace Try with the suspending constructors of Either in the context of monad transformers. Can someone point out to me how to replace Try with Either.catch in my code?

import arrow.core.Either
import arrow.core.ForEither
import arrow.core.Option
import arrow.core.Try
import arrow.fx.ForIO
import <http://arrow.fx.IO|arrow.fx.IO>
import <http://arrow.fx.extensions.io|arrow.fx.extensions.io>.applicative.applicative
import arrow.mtl.EitherT
import arrow.mtl.OptionT


typealias IOResult = EitherT<ForIO, Throwable, OptionT<ForEither, Int>>
val doesNotWork = IOResult.fromEither(IO.applicative(), Either.catch { Option.just(3) })
val doesWork = IOResult.fromEither(IO.applicative(), Try { Option.just(3)}.toEither())

when using Kotlin Coroutines a

suspend

function should not use blocking operations. How is this in the context of arrow-fx and

IO

? Is this a requirement here too or is

suspend

only used as a marker to tag functions for having sideeffects?

do i have this right?

/** left identity */
object `⟳` {
      operator fun <T> invoke(t: T) = { t: T -> t } 
}

/** left identity */
val <T> T.`⟳` get() =   `⟳` ( this) 
/**right identity*/
val <T> T.`⟲` get() = { this }

Hi guys, Android dev with 5+ years of experience looking for a job (me). Why posting here? Because

arrow-kt

connects people who loves Functional Programming and I really wish to work with

Arrow

on project or on back-end Scala.

Curious whether it would make sense or not to add type arguments of the typeclasses to their interface, e.g.

interface Functor<F, A> {
  fun <B> Kind<F, A>.map(f: (A) -> B): Kind<F, B>
}

The reason I ask is that I went to update the

Profunctor

interface to extend

Functor

and provide the default implementation for

map

using

rmap

, though the only way I could make the types line up was to update

Functor<F>

to

Functor<Kind<F, A>, B>

like so:

interface Profunctor<F, A, B> : Functor<Kind<F, A>, B> {
    fun <C, D> Kind2<F, A, B>.dimap(fl: (C) -> A, fr: (B) -> D): Kind2<F, C, D>
    fun <C> Kind2<F, A, B>.lmap(f: (C) -> A): Kind2<F, C, B> = dimap(f, ::identity)
    fun <C> Kind2<F, A, B>.rmap(f: (B) -> C): Kind2<F, A, C> = dimap(::identity, f)
    override fun <C> Kind<Kind<F, A>, B>.map(f: (B) -> C): Kind<Kind<F, A>, C> = rmap(f)
}

Is there any good document out there explaining why using something like

Kind<F, A>

is so helpful compared to

F<A>

(i.e. and e.g., not hard-coding that your return type is

Option<A>

)? I’m hoping there’s some blog out there showing a real-world reason someone chose to do this and how it benefited them. Is this just so you don’t have to refactor your function’s signatures from an

Either<Throwable, A>

into an

Option<A>

if you change your mind halfway through development, or is there something greater out there? It seems like tutorials are implying a connection to something like an

interface

in OOP (being able to write to a more generic “contract”), but I haven’t been working with FP long enough to grok the real-world benefits. Thanks.