I recently wrote about learning how C unions can be used to create optional namespaces, by creative use of both anonymous unions and anonymous structs. However, the problem in that entry is not that modern C has anonymous unions and structs (officially added in C11, a GNU extension before then, and before that a Plan 9 one). I think that what we could call "transparent" structures are a good thing in any language, not just C (Go has them too, and probably other languages as well).

Let's start with a traditional C sub-struct:

struct common {
  int field1;
  void *field2;
};
struct fred {
  struct common sub;
  [...]
};

The sub struct is two things in one; it's both a namespace (fred.sub) and a collection of reusable field definitions. However, there's no particular reason why these thing should always have to go together, so that you're forced to create a new namespace (and exile things into it) any time you want a collection of common fields. Back when traditional C gave you no choice, people built various hacks to get common fields without the namespaces (for example, a #define that defined all of your common fields together). In Go, where this has been legal since the beginning, I believe that this "embedding" is reasonably popular, showing that there is real demand (and use) for it.

(In C11, anonymous structs and unions must be completely anonymous, without a name for the new struct or union type, but in other C dialects and other languages you can be more flexible. See the GCC documentation on Unnamed Structure and Union Fields. I'm using the term "transparent" to cover all cases where the sub-structure has no overall name and the names of its fields are directly usable, as if they were top-level fields.)

It doesn't make much sense to have namespaces without something in them, but as we've seen there's a desire to not always have to use the name of the namespace to refer to things inside it. I don't know if anyone has come up with a good syntax for this (in any language).

PS: Go officially supports fairly liberal struct embedding, but in practice its full generality is rarely used.