Add explicit type parameters to ignore functions

[cmeeren]

I'd like for ignore functions like AsyncResult.ignore (and perhaps ignoreError?) to accept explicit type parameters, just like F#'s ignore function.

My reasoning is that ignoring input is a "dangerous" operation under refactoring. For example:

doSomething |> ignore<int>

If you change doSomething so that it no longer returns int, then that may indicate that the code that previously ignored its result should now do something else with it. If you just specify ignore, you have to remember to check this yourself. If you specify an explicit type parameter, the compiler checks this for you and you have to decide in each case whether to ignore the new return type or do something else.

It is currently not possible to use explicit type parameters with e.g. AsyncResult.ignore because the definition does not use explicit type parameters. If this is changed, we can use explicit type parameters, e.g. AsyncResult.ignore<int, _>.

[njlr]

A mistake I occasionally make is mixing up Async.Ignore and AsyncResult.ignore.

asyncResult {
  do! 
    tryDoSomething
    |> Async.Ignore
}

asyncResult {
  do! 
    tryDoSomething
    |> AsyncResult.ignore
}

These mean very different things!

[cmeeren]

Indeed they do. Did you mean that was relevant for the handling of this issue?

Edit: Of course, it is relevant in the sense that explicitly specifying the type to ignore would avoid that issue since it wouldn't compile.

[TheAngryByrd]

I fully support this as I've done this to regular ignore at my codebase at work. We can even enforce it as a compiler check using RequiresExplicitTypeArguments

For reference:

[<AutoOpen>]
module Operators =

  [<RequiresExplicitTypeArguments>]
  /// <summary>
  /// Ignore the passed value. This is often used to throw away results of a computation.
  /// </summary>
  /// <param name="value">The value to ignore</param>
  /// <typeparam name="'a">the type of value to expect, and ignore</typeparam>
  /// <returns>unit</returns>
  let ignore<'a> (value: 'a) = ignore<'a> value

This doesn't stop anyone from doing ignore<_> however. (I guess that would have to be solved with Linting/Analyzers)

[cmeeren]

We can even enforce it as a compiler check using RequiresExplicitTypeArguments

Cool, I didn't know about that. But I don't think we should force this on users.

[TheAngryByrd]

But I don't think we should force this on users.

Yeah I can see that being a bit aggressive

---

Mind submitting a PR for this?