_content/doc/faq: add entry about zero-size types

Provide a reference to help clear up periodic confusion:

https://groups.google.com/g/golang-nuts/c/MXcOqW-Mf-c/m/2-24iQXSAwAJ
https://groups.google.com/g/golang-nuts/c/JBVqWYFdtC4/m/EqZxT9EYAQAJ

For golang/go#2620
For golang/go#11925
For golang/go#23440
For golang/go#47950
For golang/go#52772
For golang/go#58483
For golang/go#65878

Change-Id: I0986b35d02f2fe88d5a08af1f7d1f50510c39d7c
Reviewed-on: https://go-review.googlesource.com/c/website/+/594515
Reviewed-by: Rob Pike <[email protected]>
Auto-Submit: Ian Lance Taylor <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>
Reviewed-by: Ian Lance Taylor <[email protected]>
Reviewed-by: Robert Griesemer <[email protected]>
Commit-Queue: Ian Lance Taylor <[email protected]>

Author: ianlancetaylor

_content/doc/faq.md

@@ -799,6 +799,46 @@ has been stored in the interface, the interface will not be `nil`.
 For more information, see
 [The Laws of Reflection](/doc/articles/laws_of_reflection.html).
 
+### Why do zero-size types behave oddly? {#zero_size_types}
+
+Go supports zero-size types, such as a struct with no fields
+(`struct{}`) or an array with no elements (`[0]byte`).
+There is nothing you can store in a zero-size type, but these types
+are sometimes useful when no value is needed, as in
+`map[int]struct{}` or a type that has methods but no value.
+
+Different variables with a zero-size type may be placed at the same
+location in memory.
+This is safe as no value can be stored in those variables.
+
+Moreover, the language does not make any guarantees as to whether
+pointers to two different zero-size variables will compare equal or
+not.
+Such comparisons may even return `true` at one point in the program
+and then return `false` at a different point, depending on exactly how
+the program is compiled and executed.
+
+A separate issue with zero-size types is that a pointer to a zero-size
+struct field must not overlap with a pointer to a different object in
+memory.
+That could cause confusion in the garbage collector.
+This means that if the last field in a struct is zero-size, the struct
+will be padded to ensure that a pointer to the last field does not
+overlap with memory that immediately follows the struct.
+Thus, this program:
+
+```
+func main() {
+	type S struct {
+		f1 byte
+		f2 struct{}
+	}
+	fmt.Println(unsafe.Sizeof(S{}))
+}
+```
+
+will print `2`, not `1`, in most Go implementations.
+
 ### Why are there no untagged unions, as in C? {#unions}
 
 Untagged unions would violate Go's memory safety