code: func NewStructType(fields []StructField) *StructType {
  	// Start by looking up just the types
  	fts := make([]Type, len(fields))
  	for i, f := range fields {
  		fts[i] = f.Type
  	}
  	tMapI := structTypes.Get(fts)
  	if tMapI == nil {
  		tMapI = structTypes.Put(fts, make(map[string]*StructType))
  	}
  	tMap := tMapI.(map[string]*StructType)
  
  	// Construct key for field names
  	key := ""
  	for _, f := range fields {
  		// XXX(Spec) It's not clear if struct { T } and struct
  		// { T T } are either identical or compatible.  The
  		// "Struct Types" section says that the name of that
  		// field is "T", which suggests that they are
  		// identical, but it really means that it's the name
  		// for the purpose of selector expressions and nothing
  		// else.  We decided that they should be neither
  		// identical or compatible.
  		if f.Anonymous {
  			key += "!"
  		}
  		key += f.Name + " "
  	}
  
  	// XXX(Spec) Do the tags also have to be identical for the
  	// types to be identical?  I certainly hope so, because
  	// otherwise, this is the only case where two distinct type
  	// objects can represent identical types.
  
  	t, ok := tMap[key]
  	if !ok {
  		// Create new struct type
  		t = &StructType{commonType{}, fields}
  		tMap[key] = t
  	}
  	return t
  }
docs: // Two struct types are identical if they have the same sequence of
  // fields, and if corresponding fields have the same names and
  // identical types. Two anonymous fields are considered to have the
  // same name.