func (v *Validation) Min(obj interface{}, min int, key string) *ValidationResult {
	return v.apply(Min{min, key}, obj)
}
Test that the obj is greater than min if obj's type is int
package validation
import (
	"fmt"
	"reflect"
	"regexp"
	"strings"
	"github.com/coscms/tagfast"
)
type ValidFormer interface {
	Valid(*Validation)
}
type ValidationError struct {
	Message, Key, Name, Field, Tmpl string
	Value                           interface{}
	LimitValue                      interface{}
}
func (e *ValidationError) String() string {
	if e == nil {
		return ""
	}
	return e.Message
}
type ValidationResult struct {
	Error *ValidationError
	Ok    bool
}
func (r *ValidationResult) Key(key string) *ValidationResult {
	if r.Error != nil {
		r.Error.Key = key
	}
	return r
}
func (r *ValidationResult) Message(message string, args ...interface{}) *ValidationResult {
	if r.Error != nil {
		if len(args) == 0 {
			r.Error.Message = message
		} else {
			r.Error.Message = fmt.Sprintf(message, args...)
		}
	}
	return r
}
type Validation struct {
	Errors    []*ValidationError
	ErrorsMap map[string]*ValidationError
}
func (v *Validation) Clear() {
	v.Errors = []*ValidationError{}
}
func (v *Validation) HasErrors() bool {
	return len(v.Errors) > 0
}
func (v *Validation) ErrorMap() map[string]*ValidationError {
	return v.ErrorsMap
}
func (v *Validation) Error(message string, args ...interface{}) *ValidationResult {
	result := (&ValidationResult{
		Ok:    false,
		Error: &ValidationError{},
	}).Message(message, args...)
	v.Errors = append(v.Errors, result.Error)
	return result
}
func (v *Validation) Required(obj interface{}, key string) *ValidationResult {
	return v.apply(Required{key}, obj)
}