[go-nuts] Deciding between using a method and a function

Methods (are the only way to) satisfy interfaces in Go, yes, so sometimes
you'll even write interfaces on an empty struct type (which by definition,
can have no data/state of its own) just to satisfy an interface with static
behavior -- this is sometimes done for net/http handlers. However, if it
seems suitable for a type to modify itself, use methods.

For example, if you were going to provide a single alternative hashtable
implementation, you'd just put methods on the type, as opposed to
package-level functions.

If you want to provide common 'base' implementations for interfaces, as
you'd do in OOP languages with overridable base class methods, functions
are used for that.

For example, if you provided a number of different hashtable
implementations with different performance/storage characteristics, but
with semantically identical operations, you'd make them each implement a
common, minimal 'Map' interface, and then for any tedious,
difficult-to-implement, but common (and non-performance critical) behaviors
that can be based on those minimal interface methods, you provide a
package-level function that implements that behavior once (an example of
this is the sort package), and you can also provide something like:

type MapType int
const (
TreeMap MapType = iota
HashMap
// etc
)
func MakeMap(backend MapType) Map { ... }

The above MapMap func would take a value which indicates the underlying
implementation to use, and would return one of the implementations that had
been registered or hardcoded into the package. An example of this is the
crypto package.