Simplify ignore return values

[lucasteles]

The problem

When working with interop code it's common to have a |> ignore on almost every line and every callback action. Eg:

Simple EF case:

builder.HasKey'(fun x -> x.Id)  |> ignore
builder.Ignore'(fun x -> x.Bar) |> ignore
builder.HasOne(typeof<Foo>, "_foo").WithMany().HasForeignKey("MeuMapaId") |> ignore

Basically, any other .NET lib not made for F# is like

    let builder = WebApplication.CreateBuilder()
    // hided 
    let app =    builder.Build()
    
    if not (app.Environment.IsProduction()) then
        app.UseDeveloperExceptionPage() |> ignore

    app.UseResponseCompression() |> ignore
    app.UseHttpsRedirection() |> ignore
    app.UseRouting() |> ignore
    app.UseSwagger() |> ignore
    app.UseSwaggerUI() |> ignore
    app.UseAuthentication() |> ignore
    app.UseAuthorization() |> ignore
 
    // double ignore   
    app.UseEndpoints(fun endpoints -> endpoints.MapControllers() |> ignore) |> ignore

And when Action<T> it is worse, formatting is pain, and legibility is warmed

  builder.Services.AddDbContext<AstroContext> (fun options ->
      options.UseNpgsql(
          coonectionString,
          fun x ->
              x.MigrationsAssembly("Other.Assembly")
              |> ignore
      )
      |> ignore) |> ignore

This pattern makes porting simple code into a very cumbersome translation, with lots of difficulty for people who are familiarized with default .NET APIs to just get in in F#

Putting the ignore at the front of some expressions could make them simple/small, but I feel that it gives a wrong meaning to the expression like it should not important at all, it's more a semantic issue

So, what could be a solution?

I think that disabling the warnings for a whole file would not be a good solution, ignore would still be necessary for Actions<T> and we would lose valid cases which we don't want to ignore values

I believe this is a paper cut case that is so common that would be healthy to have an alternative

I can think 2 suggestions to make this less noisy

Postfix ignore operator

With this, we would still have to ignore returns explicitly, but with priority and not affecting legibility that much.

    let builder = WebApplication.CreateBuilder()
    let app =    builder.Build()
    
    if not (app.Environment.IsProduction()) then
        app.UseDeveloperExceptionPage()!

    app.UseResponseCompression()!
    app.UseHttpsRedirection()!
    app.UseRouting()!
    app.UseSwagger()!
    app.UseSwaggerUI()!
    app.UseAuthentication()!
    app.UseAuthorization()!
 
    // double ignore   
    app.UseEndpoints(fun endpoints -> endpoints.MapControllers()!)!

Ignore block scope

A block that doesn't complain about not unit return values

    let builder = WebApplication.CreateBuilder()
    let app =    builder.Build()

    do void 
        if not (app.Environment.IsProduction()) then
            app.UseDeveloperExceptionPage()
    
        app.UseResponseCompression()
        app.UseHttpsRedirection()
        app.UseRouting()
        app.UseSwagger()
        app.UseSwaggerUI()
        app.UseAuthentication()
        app.UseAuthorization()

        // would still need to use ignore in Action<T>
        // how bad would be to have implicit ignore when filling Action<T> callbacks?
        app.UseEndpoints(fun endpoints -> endpoints.MapControllers() |> ignore)

I honestly prefer the first approach, but the idea here is to discuss this.

Workaround

Today a way to get around this is to put the expressions in a list and ignore it, which looks more like a kludge than a proper solution

    let builder = WebApplication.CreateBuilder()

    let app = builder.Build()
    [ if not (app.Environment.IsProduction()) then
          app.UseDeveloperExceptionPage() 

      app.UseResponseCompression() 
      app.UseHttpsRedirection() 
      app.UseRouting() 
      app.UseSwagger()
      app.UseSwaggerUI() 
      app.UseAuthentication() 
      app.UseAuthorization()
      app.UseEndpoints(fun endpoints -> endpoints.MapControllers() |> ignore) ] |> ignore

[Happypig375]

These methods don't return unit because they are fluent interfaces.

    WebApplication.CreateBuilder().Build()
        .UseResponseCompression()
        .UseHttpsRedirection()
        .UseRouting()
        .UseSwagger()
        .UseSwaggerUI()
        .UseAuthentication()
        .UseAuthorization()
        .UseEndpoints(fun endpoints -> endpoints.MapControllers() |> ignore)
    |> fun app ->
    if not (app.Environment.IsProduction()) then
        app.UseDeveloperExceptionPage() |> ignore

[lucasteles]

I know that the sample was for illustrate this kinda problem, mainly when the fluent interface break or does not exist

[NinoFloris]

@lucasteles I don't disagree the interop pain exists, especially minimal api feels terrible to use because of it.

Map{Verb} returns RouteHandlerBuilder on which you can't chain another Map{Verb} which forces |> ignore for each call.

type IEndpointRouteBuilder with
    member builder.MapTodo() : IEndpointConventionBuilder =
        // Todos
        builder.MapGet("/todo", ...) |> ignore 
        builder.MapGet("/todo/{todoId:int}", ...) |> ignore
        builder
            .MapPost("/todo", ...)
            .RequireAuthorization() |> ignore
        builder
            .MapDelete("todo/{todoId:int}", ...)
            .RequireAuthorization() |> ignore

I worked around it with a custom fluent computation expression (similar to the list cludge but just a bit more intentful).
Either way F# needs a better built-in solution in the box.

[Tarmil]

Something like this for the computation expression?

type IgnoreBuilder() =
    member inline _.Delay([<InlineIfLambda>] f) = f()
    member inline _.Yield(_) = ()
    member inline _.Combine((), ()) = ()
    member inline _.Zero() = ()

let ignoreAll = IgnoreBuilder()

// Example:
ignoreAll {
    app.UseResponseCompression()
    app.UseHttpsRedirection()
    app.UseRouting()
    app.UseSwagger()
    app.UseSwaggerUI()
    app.UseAuthentication()
    app.UseAuthorization()
}

[lucasteles]

@NinoFloris on point, I feel bad to have to create lot of custom operators and computations to clue native tools in a sane way, I ended creating a CE as an extension for Minimal more because of function to delegate issues #1131 #1145

let app = builder.Build()
     
app {
    mapGet "/person" (fun () ->
        use conn = getConnection()
        conn.Query<Person>("SELECT * FROM PERSON"))
   
    mapGet "/person/{id}" (fun (id: int) ->
        use conn = getConnection()
        conn.QuerySingle<Person>("SELECT * FROM PERSON WHERE ID = @ID", {|Id = id|}))
    
    mapPost "/person" (fun (person: Person) ->
        use conn = getConnection()
        conn.Execute("INSERT INTO PERSON(Name) VALUES(@Name)", {|Name = person.Name|}) |> ignore
        Results.Ok())
}

app.Run()

[lucasteles]

@Tarmil good workaround too!
I would change de name because feels like all the body would be ignored 😅

[NinoFloris]

@lucasteles I added the following overloads to the builder instead of a CE

    type IEndpointRouteBuilder with
        member builder.MapGet(pattern: string, handler: Func<'T, 'U>) =
            builder.MapGet(pattern, handler :> Delegate)
        member builder.MapGet(pattern: string, handler: Func<'T, 'U, 'V>) =
            builder.MapGet(pattern, handler :> Delegate)
        member builder.MapGet(pattern: string, handler: Func<'T, 'U, 'V, 'X>) =
            builder.MapGet(pattern, handler :> Delegate)
        member builder.MapGet(pattern: string, handler: Func<'T, 'U, 'V, 'X, 'Y>) =
            builder.MapGet(pattern, handler :> Delegate)
        member builder.MapGet(pattern: string, handler: Func<'T, 'U, 'V, 'X, 'Y, 'Z>) =
            builder.MapGet(pattern, handler :> Delegate)

        member builder.MapPost(pattern: string, handler: Func<'T, 'U>) =
            builder.MapPost(pattern, handler :> Delegate)
        member builder.MapPost(pattern: string, handler: Func<'T, 'U, 'V>) =
            builder.MapPost(pattern, handler :> Delegate)
        member builder.MapPost(pattern: string, handler: Func<'T, 'U, 'V, 'X>) =
            builder.MapPost(pattern, handler :> Delegate)
        member builder.MapPost(pattern: string, handler: Func<'T, 'U, 'V, 'X, 'Y>) =
            builder.MapPost(pattern, handler :> Delegate)
        member builder.MapPost(pattern: string, handler: Func<'T, 'U, 'V, 'X, 'Y, 'Z>) =
            builder.MapPost(pattern, handler :> Delegate)

        member builder.MapPut(pattern: string, handler: Func<'T, 'U>) =
            builder.MapPut(pattern, handler :> Delegate)
        member builder.MapPut(pattern: string, handler: Func<'T, 'U, 'V>) =
            builder.MapPut(pattern, handler :> Delegate)
        member builder.MapPut(pattern: string, handler: Func<'T, 'U, 'V, 'X>) =
            builder.MapPut(pattern, handler :> Delegate)
        member builder.MapPut(pattern: string, handler: Func<'T, 'U, 'V, 'X, 'Y>) =
            builder.MapPut(pattern, handler :> Delegate)
        member builder.MapPut(pattern: string, handler: Func<'T, 'U, 'V, 'X, 'Y, 'Z>) =
            builder.MapPut(pattern, handler :> Delegate)

        member builder.MapDelete(pattern: string, handler: Func<'T, 'U>) =
            builder.MapDelete(pattern, handler :> Delegate)
        member builder.MapDelete(pattern: string, handler: Func<'T, 'U, 'V>) =
            builder.MapDelete(pattern, handler :> Delegate)
        member builder.MapDelete(pattern: string, handler: Func<'T, 'U, 'V, 'X>) =
            builder.MapDelete(pattern, handler :> Delegate)
        member builder.MapDelete(pattern: string, handler: Func<'T, 'U, 'V, 'X, 'Y>) =
            builder.MapDelete(pattern, handler :> Delegate)
        member builder.MapDelete(pattern: string, handler: Func<'T, 'U, 'V, 'X, 'Y, 'Z>) =
            builder.MapDelete(pattern, handler :> Delegate)

Then you can just use it directly with the fluent CE.
This resulted in the most 'native' feel of all the options for me.

type IEndpointRouteBuilder with
    member builder.MapTodo() : IEndpointConventionBuilder = fluent {
        // Todos
        builder.MapGet("/todo", fun (query: Example) -> ...)
        builder.MapGet("/todo/{todoId:int}", fun (todoId: int) (query: Example) -> ...)
        builder
            .MapPost("/todo", fun (query: Bar) -> ...)
            .RequireAuthorization()
        builder
            .MapDelete("todo/{todoId:int}", fun (todoId: int) (query: Example) -> ...)
            .RequireAuthorization()
    }

[lucasteles]

@NinoFloris good point, I will try this way. Is this fluent CE just an ignore-all?

In these extensions, you could 'omit' the generic type names, it's easier to implement to the magic 15th parameter 😅

   member builder.MapGet(pattern: string, handler: Func<_, _, _>) =
        builder.MapGet(pattern, handler :> Delegate)
    member builder.MapGet(pattern: string, handler: Func<_, _, _, _>) =
        builder.MapGet(pattern, handler :> Delegate)
    // ...
    member builder.MapPost(pattern: string, handler: Func<_, _, _>) =
        builder.MapPost(pattern, handler :> Delegate)
    member builder.MapPost(pattern: string, handler: Func<_, _, _, _>) =
        builder.MapPost(pattern, handler :> Delegate)
    // ...
    member builder.MapPut(pattern: string, handler: Func<_, _, _>) =
        builder.MapPut(pattern, handler :> Delegate)
    member builder.MapPut(pattern: string, handler: Func<_, _, _, _>) =
        builder.MapPut(pattern, handler :> Delegate)
    // ...
    member builder.MapDelete(pattern: string, handler: Func<_, _, _>) =
        builder.MapDelete(pattern, handler :> Delegate)
    member builder.MapDelete(pattern: string, handler: Func<_, _, _, _>) =
        builder.MapDelete(pattern, handler :> Delegate)
    member builder.MapDelete(pattern: string, handler: Func<_, _, _, _, _>) =
        builder.MapDelete(pattern, handler :> Delegate)
    // ...

[drk-mtr]

In case anyone else stumbles across this and wants another option for a workaround, one approach is to add this to the file in question.

#nowarn "20"

[Xyncgas]

this is amazing

[abelbraaksma]

This was mentioned in the OP. You really shouldn’t do this. Warning ‘20’ is pivotal in finding mistakes in code. Since warnings are currently file wide, and cannot yet be localised, this leads to less safe code. This, too, was mentioned in the OP.

[drk-mtr]

I agree and I wouldn't use it personally, however I didn't see this in the original post. I believe it is used in the dotnet new webapi template.

[xp44mm]

I agree with @Happypig375, because the code can be translated from f# to C#, or vice versa.

The use of prepositional grammar let _ = maybe provide you with another tool.

let builder = WebApplication.CreateBuilder()
// hided 
let app = builder.Build()
    
if not (app.Environment.IsProduction()) then
    app.UseDeveloperExceptionPage() |> ignore

let _ = app.UseResponseCompression()
let _ = app.UseHttpsRedirection()
let _ = app.UseRouting()
let _ = app.UseSwagger()
let _ = app.UseSwaggerUI()
let _ = app.UseAuthentication()
let _ = app.UseAuthorization()
 
// double ignore   
let _ = app.UseEndpoints(fun endpoints -> endpoints.MapControllers() |> ignore)

[Xyncgas]

C# and F# is two different domain, if one needed to work having returns while the others dislike it, then a layer to glue the two domain together is supposed to be implemented by you