I think that not operator will become deprecated in order to flatmap operations

hello! I’m struggling a bit to figure out some logic that uses two

Option<T>

properties

fun example() {
    val maybeFoo: Option<DateTime>
    val maybeBar: Option<DateTime>

    // nested fold feels gross
    val isFooAfterBar: Boolean = maybeFoo.fold(
        ifEmpty = { false },
        ifSome = { foo ->
            maybeBar.fold(
                ifEmpty = { true },
                ifSome = { bar -> foo.isAfter(bar) }
            )
        }
    )

    // slightly better? same underlying logic though
    val isFooAfterBarAlt: Boolean = maybeFoo.map { foo ->
        maybeBar.map { bar -> foo.isAfter(bar) }.getOrElse { true }
    }.getOrElse { false }
}

this code works, but I feel like there’s probably a better solution rather than nesting

fold

🤔 the logic is basically: if

maybeFoo

is

none()

, return

false

if

maybeFoo

is

some()

and

maybeBar

is

none()

, return true if

maybeFoo

is

some()

and

maybeBar

is

some()

, return

foo > bar

any advice would be greatly appreciated! thanks

nesting fold, or a when with 2 clauses, is reasonable

it’s pattern matching

if 

maybeFoo

 is 

some()

 and 

maybeBar

 is 

none()

, return true

this clause is the one that makes the logic not fit something like

Option.applicative().map

if it was false if either is false, else

foo > bar

, then map would have worked 😄

yeah I tried using applicative and realized that it wasn’t possible here. ok cool, thanks for the reply!

The link tinyurl.com/ArrowKtExamples in @pakoito's video

Simple Dependency Management in Kotlin

gives a 404 on Github. Would anyone happen to have a different URL for the code?

…I don’t know where they went either

Could anyone give me an example /link of how

Either.catch

is used? I cannot find it.

it’s what you posted above

except the function has

suspend

there’s no more mystery to it

I imagine this is simple to do, but I'm struggling. I have

List<Option<String>>

and I want to return

List<String>

i.e. filter every None. Any tips? Ahh filterMap got it!

there’s always a function, isn’t there? 😉

haha its so great

things are starting to click which is really nice

I’m unsure about the conventions for the arrow documentation but is there a reason that the needed artefact is not mentioned on https://arrow-kt.io/docs/0.10/integrations/retrofit/#retrofit I only got this working after adding

io.arrow-kt:arrow-integration-retrofit-adapter:0.10.4

to my dependencies. Is there a way to create an issue or pull request to improve that page?

yes!

Another question regarding the sample code from that page.

call.runAsync(IO.async())

Android studio tricked me into using

fun <A> async(k: IOProc<A>): IO<A> = .....

From the IO class instead of the one from the IOAsync extensions file.

is this something that should be corrected in the docs or how do I know which async() to use?

one takes parameters and the other doesn't. The types of the non-parameters one should align too

I don't know why IJ was confused

Yeah for some reason the one from the extensions is not correctly found

it's on a different module altogether, maybe you haven't included it

It worked after manually adding the import

What is the difference between:

fun prepareLunchOption(): Option<Salad> =
  fx.monad {
    val lettuce = takeFoodFromRefrigerator().bind()
    val knife = getKnife().bind()
    val salad = prepare(knife, lettuce).bind()
    salad
  }

and

fun prepareLunchOption(): Option<Salad> =
  Option.fx {
    val (lettuce) = takeFoodFromRefrigerator()
    val (knife) = getKnife()
    val (salad) = prepare(knife, lettuce)
    salad
  }