Why Are Parentheses Required After Closure Bodies in Go's Deferred Statements?

Closure Invocations in Go

In Go, the usage of parentheses after the body of a closure is not limited to closure contexts. The core concept that governs this behavior is that expressions within deferred statements must be function calls.

Function Literals with Closures

Consider a function literal such as func(ch chan int) { ch <- ACK }(), where the parentheses follow the closure body. This syntax encloses the closure in an immediately invoked function call. This allows the function to execute upon initialization, passing the argument replyChan to the closure.

Deferred Statements

In deferred statements, such as defer func() { result }(), the parentheses ensure that the enclosed expression is a function call. Without this syntax, the expression would be incomplete and not a valid function call. The syntax for deferred statements therefore mandates that the expression must be a function invocation.

Orthogonality with Function Calls

This orthogonality ensures consistency with function calls outside of deferred statements. For example, f(), where f is a function value, represents a function invocation that returns a value. In contrast, f, without parentheses, represents the function value itself. This parallel syntax applies to expressions within deferred statements as well.

Closure Execution

In a closure defined within a deferred statement, the parentheses determine when the closure will execute. For example, in defer func() { fmt. Println(i) }(), the closure executes immediately when the defer statement is encountered, capturing the current value of i. In contrast, defer func(n int) { fmt. Println(n) }(i) captures and prints the value of i at the time of the defer statement execution, not when the closure executes.

The above is the detailed content of Why Are Parentheses Required After Closure Bodies in Go's Deferred Statements?. For more information, please follow other related articles on the PHP Chinese website!