code: func New() *Validate {
  
  	tc := new(tagCache)
  	tc.m.Store(make(map[string]*cTag))
  
  	sc := new(structCache)
  	sc.m.Store(make(map[reflect.Type]*cStruct))
  
  	v := &Validate{
  		tagName:     defaultTagName,
  		aliases:     make(map[string]string, len(bakedInAliases)),
  		validations: make(map[string]FuncCtx, len(bakedInValidators)),
  		tagCache:    tc,
  		structCache: sc,
  	}
  
  	// must copy alias validators for separate validations to be used in each validator instance
  	for k, val := range bakedInAliases {
  		v.RegisterAlias(k, val)
  	}
  
  	// must copy validators for separate validations to be used in each instance
  	for k, val := range bakedInValidators {
  
  		// no need to error check here, baked in will always be valid
  		_ = v.registerValidation(k, wrapFunc(val), true)
  	}
  
  	v.pool = &sync.Pool{
  		New: func() interface{} {
  			return &validate{
  				v:        v,
  				ns:       make([]byte, 0, 64),
  				actualNs: make([]byte, 0, 64),
  				misc:     make([]byte, 32),
  			}
  		},
  	}
  
  	return v
  }
docs: // New returns a new instance of 'validate' with sane defaults.