ignore keyword giving unexpected results

[MarcDHall]

Repro steps

open System.Threading.Channels
open FSharp.Control

let channel = Channel.CreateUnbounded<int>();

let puts = task {
    return! 0 |> channel.Writer.WriteAsync
    return! 1 |> channel.Writer.WriteAsync  
} 

puts |> Async.AwaitTask |> Async.RunSynchronously |> ignore

channel.Writer.Complete |> ignore 

channel.Reader.ReadAllAsync()
|> AsyncSeq.ofAsyncEnum
|> AsyncSeq.iter (fun x -> printfn "%i" x)
|> Async.RunSynchronously
|> ignore

"Done" |> System.Console.WriteLine |> ignore;

Expected behavior
The IAsyncEnumerable returned by ReadAllAsync() should behave like a finite set of 2 elements and come to an end.

Actual behavior
The IAsyncEnumerable never ends. "Done" is never written to the stdout. The Channel isn't marked as closed.

Workaround
Swapping to channel.Writer.Complete() will cause this code to terminate.

I am new to F#, so this might be my ignorance, but my understanding is that Complete() and Complete |> ignore should be equivalent in this case. The only odd thing about channel.Writer.Complete, that I can see, is that it takes an optional parameter. Have I missed something obvious here? I couldn't find any mention of this type of behaviour while everything I've read suggests that |> ignore is the correct, idiomatic syntax.

[kerams]

ignore is used to throw away a value ("convert" it to a unit). If you drop the parentheses, you never call the method. Instead, you're passing it, not the return value, to ignore. channel.Writer.Complete |> ignore is a no-op, it literally doesn't do anything or result in any IL instructions.

[vzarytovskii]

As @kerams mentioned, since ignore is just normal function, which takes anything and returns a unit (()), X |> ignore is an equivalent of ignore X or ignore (X), so when you're doing channel.Writer.Complete |> ignore you're essentially taking a method group and passing it to ignore, like ignore(channel.Writer.Complete) without calling it.

You probably want channel.Writer.Complete() |> ignore in this case.

[MarcDHall]

Thanks for the replies.

That's interesting. So why does this work?

"Done" |> System.Console.WriteLine |> ignore

[vzarytovskii]

Thanks for the replies.

That's interesting. So why does this work?

"Done" |> System.Console.WriteLine |> ignore

Due to piping, first you pass string "Done" to System.Console.WriteLine as argument via |>, then you pass its result (since you made a call) to the ignore, so this essentially will transform into ignore(System.Console.WriteLine("Done")).

[Happypig375]

Should we warn against ignoring a function?

[vzarytovskii]

I would say not compiler itself, since, well, ignore is just a function. Would need special treatment from the compiler in this case.
Analyzer would work though.

[Happypig375]

@vzarytovskii I remember someone proposed a [<NotAFunction>] attribute somewhere for printing functions but cannot find it currently. It can be a good way to do this.

[0101]

This works as expected. But it would be a good use case for an analyzer that could warn users that this code probably won't do what they expect. Or that it doesn't make sense to ignore functions/methods.