flatMap ignoring the result

Question

I was wondering if there exists a function (in scala or cats) which omits the result within flatMap. E.g.

Some("ignore this").ignoreArgumentFlatMap(Some("result"))

which would be the same as

Some("ignore this").flatMap(_ => Some("result"))

I have some monads where the result is actually not of interest but only the inner state — Nicolas Heimann, Jan 29 '20 at 09:02
e.g. `for { x <- someFoo; _ <- anotherFoo: _ <- moreOtherFoo; _ <- derp } yield x` - database transaction for example — Nicolas Heimann, Jan 29 '20 at 09:03
hmmm... by the look of it, looks like anotherFoo, moreOtherFoo and derp are side-effecting things, right? — mfirry, Jan 29 '20 at 09:05
Yep, if one of them fail, they short circuit and the previous side effects are rolled back, in this my actual case (Doobie ConnectionIO) — Nicolas Heimann, Jan 29 '20 at 09:06
would like to write it without for-comprehension as the result does not matter — Nicolas Heimann, Jan 29 '20 at 09:07
not so sure this will help you but give a look at https://github.com/oleg-py/better-monadic-for — mfirry, Jan 29 '20 at 09:08
i think it does not solve my current problem, but its an interesting project, did no know about this, might be usefull for other parts of my project, thanks — Nicolas Heimann, Jan 29 '20 at 09:13
In your case, isn't it rather `Some("result").flatMap(x => { Some("ignore this"); Some(x) })` (to have the equivalent of your for-comprehension)? — sachav, Jan 29 '20 at 09:27
in the case of option this is correct, but there are monads for which commands in the sequence do not commute due to internal state — Nicolas Heimann, Jan 29 '20 at 10:25

Jasper-M · Accepted Answer · 2020-01-29T09:53:30.150

It is called >> in cats.

scala> import cats.implicits._
import cats.implicits._

scala> Option("ignore this") >> Some("result")
res14: Option[String] = Some(result)

The documentation explicitly says

Alias for fa.flatMap(_ => fb).

Unlike *>, fb is defined as a by-name parameter, allowing this method to be used in cases where computing fb is not stack safe unless suspended in a flatMap.

There's also productR or *>.

scala> Option("ignore this").productR(Some("result"))
res15: Option[String] = Some(result)

scala> Option("ignore this") *> Some("result")
res16: Option[String] = Some(result)

Like the doc said its argument is not by-name though. So it's more or less equivalent to

val x0 = Some("result")
Some("ignore this").flatMap(_ => x0)

There's productREval if you want an alternative evaluation strategy.

is there also an analogue for "map"? e.g. `x.ignoreMap(someValue)` would be `x.map(_ => someValue)`? — Nicolas Heimann, Jan 29 '20 at 11:20
@keksnicoh I think that's `x.as(someValue)` but again it's not by-name. — Jasper-M, Jan 29 '20 at 13:12

flatMap ignoring the result

1 Answers1