A modern programming language that makes developers happier.

kotlinlang

If I have:
```val foo: Either&lt;Error, List&lt;Bar&gt;&gt;?

nullable {
   val baz: List&lt;Bar&gt; = foo.bind().bind() // this doesn't seem to be valid... how do I do this?

   val baz2: List&lt;Bar&gt; = ensureNotNull(foo).bind() // this also doesn't seem to be valid...
}```

inside `nullable` you can only `raise` values of type `null` (so you don’t “forget” information, although this design could be revisited)

you should be able to do
```foo.mapLeft { null }.bind()```

sorry, my bad, I didn’t see the `?` at the end

then it should be something like
```foo.bind().mapLeft { null }.bind()```

Which isn't really as readable... maybe having `bind()` with a different name for this, so that people will make the conscious choice to ignore the extra information...

The whole point I chose to use `nullable { }` was to go with the happy path... and let everything else be null.

Maybe `bind { null }`  for `Either`s? Or ``bindOrMap { null }` ... would be better than using two different binds meaning two different things and that map in the middle...

what do you think of <https://github.com/arrow-kt/arrow/pull/3099> ?

(if it seems a good design I will add KDoc and those things)

From looking at the tests I don't really understand what the difference between bind() and bindAny() is...?

Good to note btw that you can do:
```nullable {
  withError({ _: Any? -&gt; null}) {
    foo.bind().bind()
  }
}
```
Maybe this pattern should have a raise builder? Maybe something like `nullableAny {}` that forgets all the error information.

Looking at the PR, I don't like the design of `raiseAny` because it won't work well with context receivers. I think nullable should simply have `Raise&lt;Any?&gt;` Inside of it, or we should introduce a new builder that does that, but having a new method won't work in a contexts world.

I think the idea was to be able to "choose" whether to ignore or not in the same block. With a new builder, you're choosing to ignore everything and might inadvertently ignore something important.

Hmmmmm, then maybe we could have both worlds? Or we could have a `ignoreErrors { }` block that only works inside a `Raise&lt;Null&gt;` and gives you a receiver of `Raise&lt;Any?&gt;`, Although I can see how that's less user friendly

that’s interesting… I’ll try that one too :slightly_smiling_face:

this is the alternative <https://github.com/arrow-kt/arrow/pull/3100>

I like the connection brought by <@U019AG342E5> with `withError`, because `ignoreErrors` is simply `withError` with a bit better inference

Thanks for this PR! I guess out of this whole discussion that's really the best that can be done, and it'll certainly come in handy in certain cases!

merged! it will come out in 1.2.1 (which is now stuck because of problems with Kotlin 1.9)