Rename & repurpose result.then

[NthTensor]

Now that use has been released and try is intended for deprecation/removal, I want to bring up a proposal I saw in discord a few days ago: I think we should consider renaming gleam/result.then to try and instead use then for the curried version.

pub fn try(
  result: Result(a, e),
  apply fun: fn(a) -> Result(b, e),
) -> Result(b, e) {
  case result {
    Ok(x) -> fun(x)
    Error(e) -> Error(e)
  }
}

pub fn then(
  result: Result(a, e)
) -> fn(apply fun: fn(a) -> Result(b, e)) -> Result(b, e) {
  fn(fun) {
    case result {
      Ok(x) -> fun(x)
      Error(e) -> Error(e)
    }
  }
}

Currently we have to write:

use result <- then(fallible_function())

which several people in the discord seem dissatisfied with. then comes before the function, but it means try the function first and then only go on if it was successful. The general consensus seems to be that then is nicer after functions, and not before. There is also no obvious & friendly way to use a result from a pipeline, as you have to do one of the following:

use result <- then(first_function()
|> second_function()
|> third_function())

use result <- first_function
|> second_function
|> third_function
|> function.curry2(then)

With these API changes, we would write

use result <- try(fallible_function())

use result <- fallible_function() |> then()

use result <- first_function()
|> second_function()
|> third_function()
|> then()

I think this is a little more readable, and probably going to be more friendly to new users. I'd love to hear what the rest of you think. More generally, I think there is no reason we need to stick to then for this sort of pattern. If we are going to have to manually re-implement it for every type anyway, we should choose names which more closely describe the particular uses of that type.

Implementing this proposal would require removing try as a keyword rather than simply deprecating it. If we would like to go the deprecation route, we could probably name the un-curried function attempt or something. The other major downside is that this would break a lot of people's code in a way that is easy but maybe slightly annoying to fix. But depreciating try would have this effect anyway, so it would be reasonable to introduce this change at the same time as the deprecation.

[lpil]

I agree, the word then doesn't fit so well with the use syntax. try would be a good name for result.then, but it is unclear to me whether we should remove the try expression from the language just yet. If we do decide to remove it we could have a result.try_ in the meantime, and we could make some tooling to automate the migration from try to use.

I'm unsure if we should add special support for pipes with use, it is nice to be able to see the name of the operation up-front

use result <- promise.await(
  first_function()
  |> second_function
  |> third_function
)

use result <- result.try(
  first_function()
  |> second_function
  |> third_function
)

[inoas]

• I am in favour of renaming result.then to result.try in any case.
• try keyword:
  • In case it gets removed: I am not sure that at the current size of the eco-system a migration support for try -> use is worth the effort.
  • I'd prefer to keep try as it clearly signals the built-in/preferred error handling of the language without manually inspecting/tracing any type signatures. I am aware that there is a feature overlap but I like signalling.

[ShalokShalom]

Every IDE has a search and replace tool that allows to change try to use easily.

[lpil]

Every IDE has a search and replace tool that allows to change try to use easily.

We would build this ourselves as a simple search replace would not be sufficiently accurate.