Handling call chains starting with a lambda call

We need to make a decision on to handle something such as this:

with(Foo()) {
  doFooStuff()
  doMoreFooStuff()
}.also {
  println("Wow")
  println("Amaze")
}

Generally in call chains, we break before a dot, and in the case of a chain with lambdas code looks like this:

fooFoo
    .callMethod {
      doFooStuff()
      doMoreFooStuff()
    }
    .also {
      println("Wow")
      println("Amaze")
    }

There is an example a . which is a when expression:

when (f) {
  ...
}.exhaustive

A few options we have:

Option 1: dot right after }.

with(Foo()) {
  doFooStuff()
  doMoreFooStuff()
}.also {
  println("Wow")
  println("Amaze")
}

Problem: The chain keeps looking different than other types of chains

Option 2

Extra indentation to make it look like if we had a chained call

with(Foo()) {
      doFooStuff()
      doMoreFooStuff()
    }
    .also {
      println("Wow")
      println("Amaze")
    }

Problem, might be weird to have the extra indentation

Option 3

Floating dot

with(Foo()) {
  doFooStuff()
  doMoreFooStuff()
}
    .also {
      println("Wow")
      println("Amaze")
    }

What option should we pursue? I have code doing option 2.

[cgrushko]

@JavierSegoviaCordoba - GitHub Discussions enabled

[hick209]

I prefer option 1 for the ones you presented.

But also, if it’s formatted differently, I’d go with option 3.

For example:

list.asSequence()
    .map { i ->
      i * 2
    }
    .also {
      println(it)
    }