anonymous struct and empty struct
Note that one interesting aspect of using struct{} for the type pushed to a channel (as opposed to int or bool), is that the size of an empty struct is... 0!
See the recent article "The empty struct" (March 2014) by Dave Cheney.
You can create as many struct{}
as you want (struct{}{}
) to push them to your channel: your memory won't be affected.
But you can use it for signaling between go routines, as illustrated in "Curious Channels".
finish := make(chan struct{})
As the behaviour of the
close(finish)
relies on signalling the close of the channel, not the value sent or received, declaringfinish
to be oftype chan struct{}
says that the channel contains no value; we’re only interested in its closed property.
And you retain all the other advantages linked to a struct:
- you can define methods on it (that type can be a method receiver)
- you can implement an interface (with said methods you just define on your empty struct)
- as a singleton
in Go you can use an empty struct, and store all your data in global variables. There will only be one instance of the type, since all empty structs are interchangeable.
See for instance the global var errServerKeyExchange
in the file where the empty struct rsaKeyAgreement
is defined.
Composite literals
Composite literals construct values for structs, arrays, slices, and maps and create a new value each time they are evaluated. They consist of the type of the value followed by a brace-bound list of composite elements. An element may be a single expression or a key-value pair.
struct{}{}
is a composite literal of type struct{}
, the type of the value followed by a brace-bound list of composite elements.
for _ = range langs { <-done }
is waiting until all the goroutines for all the langs
have sent done
messages.
struct{}
is a type (in particular, a structure with no members). If you have a typeFoo
, you can create a value of that type in an expression withFoo{field values, ...}
. Putting this together,struct{}{}
is a value of the typestruct{}
, which is what the channel expects.The
main
function spawnswarrior
goroutines, which will write to thedone
channel when they have finished. The lastfor
block reads from this channel, ensuring thatmain
won't return until all the goroutines have finished. This is important because the program will exit whenmain
completes, irrespective of whether there are other goroutines running.
Good questions,
The whole point of the struct channel in this scenario is simply to signal the completion that something useful has happened. The channel type doesn't really matter, he could have used an int or a bool to accomplish the same effect. What's important is that his code is executing in a synchronized fashion where he's doing the necessary bookkeeping to signal and move on at key points.
I agree the syntax of struct{}{}
looks odd at first because in this example he is declaring a struct and creating it in-line hence the second set of brackets.
If you had a pre-existing object like:
type Book struct{
}
You could create it like so: b := Book{}
, you only need one set of brackets because the Book struct has already been declared.