func (mux *Mux) On(verb string, pattern string, handlers ...interface{}) error {
	if verb == asterisk {
		errors := []string{}
		for _, verb := range verbs {
			if err := mux.On(verb, pattern, handlers...); err != nil {
				errors = append(errors, err.Error())
			}
		}
		if 0 == len(errors) {
			return nil
		}
		return fmt.Errorf(strings.Join(errors, "\n"))
	}
	tr, wildcards := mux.tree(verb)
	if nil == tr {
		return fmt.Errorf("bear: %s isn't a valid HTTP verb", verb)
	}
	if functions, err := handlerizeLax(verb, pattern, handlers); err != nil {
		return err
	} else {
		tr.set(verb, pattern, functions, wildcards, &err)
		return err
	}
}
On adds HTTP verb handler(s) for a URL pattern. The handler argument(s)
should either be http.HandlerFunc or bear.HandlerFunc or conform to the
signature of one of those two. NOTE: if http.HandlerFunc (or a function
conforming to its signature) is used no other handlers can *follow* it, i.e.
it is not middleware.

It returns an error if it fails, but does not panic. Verb strings are
uppercase HTTP methods. There is a special verb "*" which can be used to
answer *all* HTTP methods. It is not uncommon for the verb "*" to return
errors, because a path may already have a listener associated with one HTTP
verb before the "*" verb is called. For example, this common and useful
pattern will return an error that can safely be ignored (see error example).

Pattern strings are composed of tokens that are separated by "/" characters.
There are three kinds of tokens:

1. static path strings: "/foo/bar/baz/etc"

2. dynamically populated parameters "/foo/{bar}/baz" (where "bar" will be
populated in the *Context.Params)

3. wildcard tokens "/foo/bar/*" where * has to be the final token.
Parsed URL params are available in handlers via the Params map of the
*Context argument.

Notes:

1. A trailing slash / is always implied, even when not explicit.

2. Wildcard (*) patterns are only matched if no other (more specific)
pattern matches. If multiple wildcard rules match, the most specific takes
precedence.

3. Wildcard patterns do *not* match empty strings: a request to /foo/bar will
not match the pattern "/foo/bar/*". The only exception to this is the root
wildcard pattern "/*" which will match the request path / if no root
handler exists.
package bear
import (
	"fmt"
	"net/http"
	"strings"
)
type Mux struct {
	trees  [8]*tree       
	always []HandlerFunc  
	wild   [8]bool        
}
func parsePath(s string) (components []string, last int) {
	start, offset := 0, 0
	if slashr == s[0] {
		start = 1
	}
	if slashr == s[len(s)-1] {
		offset = 1
	}
	components = strings.SplitAfter(s, slash)
	if start == 1 || offset == 1 {
		components = components[start : len(components)-offset]
	}
	last = len(components) - 1
	if offset == 0 {
		components[last] = components[last] + slash
	}
	return components, last
}
func (mux *Mux) Always(handlers ...interface{}) error {
	if functions, err := handlerizeStrict(handlers); err != nil {
		return err
	} else {
		mux.always = append(mux.always, functions...)
		return err
	}
}