func (c CanonType) Compose(part ...interface{}) (t Tag, err error) {
	defer func() {
		if recover() != nil {
			t = Tag{}
			err = language.ErrSyntax
		}
	}()
	var b language.Builder
	if err = update(&b, part...); err != nil {
		return und, err
	}
	b.Tag, _ = canonicalize(c, b.Tag)
	return makeTag(b.Make()), err
}
Compose creates a Tag from individual parts, which may be of type Tag, Base,
Script, Region, Variant, []Variant, Extension, []Extension or error. If a
Base, Script or Region or slice of type Variant or Extension is passed more
than once, the latter will overwrite the former. Variants and Extensions are
accumulated, but if two extensions of the same type are passed, the latter
will replace the former. For -u extensions, though, the key-type pairs are
added, where later values overwrite older ones. A Tag overwrites all former
values and typically only makes sense as the first argument. The resulting
tag is returned after canonicalizing using CanonType c. If one or more errors
are encountered, one of the errors is returned.
package language
import (
	"errors"
	"strconv"
	"strings"
	"golang.org/x/text/internal/language"
)
type ValueError interface {
	error
	Subtag() string
}
func Parse(s string) (t Tag, err error) {
	return Default.Parse(s)
}
func (c CanonType) Parse(s string) (t Tag, err error) {
	defer func() {
		if recover() != nil {
			t = Tag{}
			err = language.ErrSyntax
		}
	}()
	tt, err := language.Parse(s)
	if err != nil {
		return makeTag(tt), err
	}
	tt, changed := canonicalize(c, tt)
	if changed {
		tt.RemakeString()
	}
	return makeTag(tt), err
}
func Compose(part ...interface{}) (t Tag, err error) {
	return Default.Compose(part...)
}