ParseStandardTag extracts the sub-tag named by key, then parses it using the
de facto standard format introduced in encoding/json:

"-" means "ignore this tag", unless it has options (that is, is followed by a comma),
in which case it is treated a name.
"<name>" provides an alternative name for the field
"<name>,opt1,opt2,..." specifies options after the name.

Its first argument should be a function that accepts
a struct tag and returns four values: an alternative name for the field
extracted from the tag, a boolean saying whether to keep the field or ignore
it, additional data that is stored with the field information to avoid
having to parse the tag again, and an error.

Its second argument should be a function that accepts a reflect.Type and
returns an error if the struct type is invalid in any way. For example, it
may check that all of the struct field tags are valid, or that all fields
are of an appropriate type.

Fields returns all the exported fields of t, which must be a struct type. It
follows the standard Go rules for embedded fields, modified by the presence
of tags. The result is sorted lexicographically by index.

These rules apply in the absence of tags:
Anonymous struct fields are treated as if their inner exported fields were
fields in the outer struct (embedding). The result includes all fields that
aren't shadowed by fields at higher level of embedding. If more than one
field with the same name exists at the same level of embedding, it is
excluded. An anonymous field that is not of struct type is treated as having
its type as its name.

Tags modify these rules as follows:
A field's tag is used as its name.
An anonymous struct field with a name given in its tag is treated as
a field having that name, rather than an embedded struct (the struct's
fields will not be returned).
If more than one field with the same name exists at the same level of embedding,
but exactly one of them is tagged, then the tagged field is reported and the others
are ignored.

type Field struct {
Namestring// effective field nameNameFromTagbool// did Name come from a tag?Typereflect.Type// field typeIndex []int// index sequence, for reflect.Value.FieldByIndexParsedTag interface{} // third return value of the parseTag function
// contains filtered or unexported fields
}

MatchFold returns the field in the list whose name best matches the supplied
name, nor nil if no field does. If there is a field with the exact name, it
is returned. Otherwise the first field (sorted by index) whose name matches
case-insensitively is returned.

ParseTagFunc is a function that accepts a struct tag and returns four values: an alternative name for the field
extracted from the tag, a boolean saying whether to keep the field or ignore it, additional data that is stored
with the field information to avoid having to parse the tag again, and an error.