Structs & Methods

A struct is a composite type that groups named fields, each with its own type. It is a value type: assigning or passing it copies every field. Structs support embedding (composition), methods, and field tags. Its zero value has each field at that field's own zero value, and two structs are comparable with == when all their fields are comparable.

Go has no constructors. The idiom is a plain factory function, conventionally NewT(...), that takes the inputs, validates them, and returns an initialized *T or T. It is an ordinary function, not special syntax — nothing forces callers to use it. Often the struct's zero value is already usable, so no constructor is needed at all; you write NewT only when construction must validate inputs or set up non-zero defaults.

Embedding puts a type as an unnamed field, like struct{ A }, which promotes A's fields and methods onto the outer struct so you can reach them directly. It is composition, NOT inheritance: there is no polymorphism and no virtual dispatch — the outer type is not a subtype of A. An own member with the same name shadows the embedded one, and the embedded value is still reachable explicitly through its type name, like outer.A.

A method is a function with an extra receiver parameter written before the name, like func (c Counter) Inc(). The receiver binds the method to a named type — usually a struct — declared in the same package, and you call it as c.Inc(). A plain function has no receiver and is called by its bare name. So a method is just a function whose first argument is the receiver, with nicer call syntax and a method set on the type.

Use a pointer receiver when the method must mutate the receiver, since a value receiver only gets a copy and the change is lost. Use one too when the struct is large, to avoid copying every field on each call, or for consistency when some methods on the type already need a pointer — mixing receiver kinds is discouraged. A value receiver fits small, immutable types where a copy is cheap and safe, and it also leaves the value usable concurrently.

It prints foo. A method call is sugar for passing the receiver as an argument, and Set has a value receiver, so b is a copy — b.Value = s mutates the copy and the original is untouched. Even passing &bs would still print foo, because Set copies the value regardless. Fix: make Set a pointer receiver, func (b *BasicStruct) Set(s string), and pass &bs.