How to use iterInterfaces method of main Package

...145func (p *fileParser) addAuxInterfacesFromFile(pkg string, file *ast.File) {146	if _, ok := p.auxInterfaces[pkg]; !ok {147		p.auxInterfaces[pkg] = make(map[string]*ast.InterfaceType)148	}149	for ni := range iterInterfaces(file) {150		p.auxInterfaces[pkg][ni.name.Name] = ni.it151	}152}153// parseFile loads all file imports and auxiliary files import into the154// fileParser, parses all file interfaces and returns package model.155func (p *fileParser) parseFile(importPath string, file *ast.File) (*model.Package, error) {156	allImports, dotImports := importsOfFile(file)157	// Don't stomp imports provided by -imports. Those should take precedence.158	for pkg, pkgI := range allImports {159		if _, ok := p.imports[pkg]; !ok {160			p.imports[pkg] = pkgI161		}162	}163	// Add imports from auxiliary files, which might be needed for embedded interfaces.164	// Don't stomp any other imports.165	for _, f := range p.auxFiles {166		auxImports, _ := importsOfFile(f)167		for pkg, pkgI := range auxImports {168			if _, ok := p.imports[pkg]; !ok {169				p.imports[pkg] = pkgI170			}171		}172	}173	var is []*model.Interface174	for ni := range iterInterfaces(file) {175		i, err := p.parseInterface(ni.name.String(), importPath, ni.it)176		if err != nil {177			return nil, err178		}179		is = append(is, i)180	}181	return &model.Package{182		Name:       file.Name.String(),183		PkgPath:    importPath,184		Interfaces: is,185		DotImports: dotImports,186	}, nil187}188// parsePackage loads package specified by path, parses it and returns189// a new fileParser with the parsed imports and interfaces.190func (p *fileParser) parsePackage(path string) (*fileParser, error) {191	newP := &fileParser{192		fileSet:            token.NewFileSet(),193		imports:            make(map[string]importedPackage),194		importedInterfaces: make(map[string]map[string]*ast.InterfaceType),195		auxInterfaces:      make(map[string]map[string]*ast.InterfaceType),196		srcDir:             p.srcDir,197	}198	var pkgs map[string]*ast.Package199	if imp, err := build.Import(path, newP.srcDir, build.FindOnly); err != nil {200		return nil, err201	} else if pkgs, err = parser.ParseDir(newP.fileSet, imp.Dir, nil, 0); err != nil {202		return nil, err203	}204	for _, pkg := range pkgs {205		file := ast.MergePackageFiles(pkg, ast.FilterFuncDuplicates|ast.FilterUnassociatedComments|ast.FilterImportDuplicates)206		if _, ok := newP.importedInterfaces[path]; !ok {207			newP.importedInterfaces[path] = make(map[string]*ast.InterfaceType)208		}209		for ni := range iterInterfaces(file) {210			newP.importedInterfaces[path][ni.name.Name] = ni.it211		}212		imports, _ := importsOfFile(file)213		for pkgName, pkgI := range imports {214			newP.imports[pkgName] = pkgI215		}216	}217	return newP, nil218}219func (p *fileParser) parseInterface(name, pkg string, it *ast.InterfaceType) (*model.Interface, error) {220	iface := &model.Interface{Name: name}221	for _, field := range it.Methods.List {222		switch v := field.Type.(type) {223		case *ast.FuncType:224			if nn := len(field.Names); nn != 1 {225				return nil, fmt.Errorf("expected one name for interface %v, got %d", iface.Name, nn)226			}227			m := &model.Method{228				Name: field.Names[0].String(),229			}230			var err error231			m.In, m.Variadic, m.Out, err = p.parseFunc(pkg, v)232			if err != nil {233				return nil, err234			}235			iface.AddMethod(m)236		case *ast.Ident:237			// Embedded interface in this package.238			embeddedIfaceType := p.auxInterfaces[pkg][v.String()]239			if embeddedIfaceType == nil {240				embeddedIfaceType = p.importedInterfaces[pkg][v.String()]241			}242			var embeddedIface *model.Interface243			if embeddedIfaceType != nil {244				var err error245				embeddedIface, err = p.parseInterface(v.String(), pkg, embeddedIfaceType)246				if err != nil {247					return nil, err248				}249			} else {250				// This is built-in error interface.251				if v.String() == model.ErrorInterface.Name {252					embeddedIface = &model.ErrorInterface253				} else {254					return nil, p.errorf(v.Pos(), "unknown embedded interface %s", v.String())255				}256			}257			// Copy the methods.258			for _, m := range embeddedIface.Methods {259				iface.AddMethod(m)260			}261		case *ast.SelectorExpr:262			// Embedded interface in another package.263			filePkg, sel := v.X.(*ast.Ident).String(), v.Sel.String()264			embeddedPkg, ok := p.imports[filePkg]265			if !ok {266				return nil, p.errorf(v.X.Pos(), "unknown package %s", filePkg)267			}268			var embeddedIface *model.Interface269			var err error270			embeddedIfaceType := p.auxInterfaces[filePkg][sel]271			if embeddedIfaceType != nil {272				embeddedIface, err = p.parseInterface(sel, filePkg, embeddedIfaceType)273				if err != nil {274					return nil, err275				}276			} else {277				path := embeddedPkg.Path()278				parser := embeddedPkg.Parser()279				if parser == nil {280					ip, err := p.parsePackage(path)281					if err != nil {282						return nil, p.errorf(v.Pos(), "could not parse package %s: %v", path, err)283					}284					parser = ip285					p.imports[filePkg] = importedPkg{286						path:   embeddedPkg.Path(),287						parser: parser,288					}289				}290				if embeddedIfaceType = parser.importedInterfaces[path][sel]; embeddedIfaceType == nil {291					return nil, p.errorf(v.Pos(), "unknown embedded interface %s.%s", path, sel)292				}293				embeddedIface, err = parser.parseInterface(sel, path, embeddedIfaceType)294				if err != nil {295					return nil, err296				}297			}298			// Copy the methods.299			// TODO: apply shadowing rules.300			for _, m := range embeddedIface.Methods {301				iface.AddMethod(m)302			}303		default:304			return nil, fmt.Errorf("don't know how to mock method of type %T", field.Type)305		}306	}307	return iface, nil308}309func (p *fileParser) parseFunc(pkg string, f *ast.FuncType) (inParam []*model.Parameter, variadic *model.Parameter, outParam []*model.Parameter, err error) {310	if f.Params != nil {311		regParams := f.Params.List312		if isVariadic(f) {313			n := len(regParams)314			varParams := regParams[n-1:]315			regParams = regParams[:n-1]316			vp, err := p.parseFieldList(pkg, varParams)317			if err != nil {318				return nil, nil, nil, p.errorf(varParams[0].Pos(), "failed parsing variadic argument: %v", err)319			}320			variadic = vp[0]321		}322		inParam, err = p.parseFieldList(pkg, regParams)323		if err != nil {324			return nil, nil, nil, p.errorf(f.Pos(), "failed parsing arguments: %v", err)325		}326	}327	if f.Results != nil {328		outParam, err = p.parseFieldList(pkg, f.Results.List)329		if err != nil {330			return nil, nil, nil, p.errorf(f.Pos(), "failed parsing returns: %v", err)331		}332	}333	return334}335func (p *fileParser) parseFieldList(pkg string, fields []*ast.Field) ([]*model.Parameter, error) {336	nf := 0337	for _, f := range fields {338		nn := len(f.Names)339		if nn == 0 {340			nn = 1 // anonymous parameter341		}342		nf += nn343	}344	if nf == 0 {345		return nil, nil346	}347	ps := make([]*model.Parameter, nf)348	i := 0 // destination index349	for _, f := range fields {350		t, err := p.parseType(pkg, f.Type)351		if err != nil {352			return nil, err353		}354		if len(f.Names) == 0 {355			// anonymous arg356			ps[i] = &model.Parameter{Type: t}357			i++358			continue359		}360		for _, name := range f.Names {361			ps[i] = &model.Parameter{Name: name.Name, Type: t}362			i++363		}364	}365	return ps, nil366}367func (p *fileParser) parseType(pkg string, typ ast.Expr) (model.Type, error) {368	switch v := typ.(type) {369	case *ast.ArrayType:370		ln := -1371		if v.Len != nil {372			var value string373			switch val := v.Len.(type) {374			case (*ast.BasicLit):375				value = val.Value376			case (*ast.Ident):377				// when the length is a const defined locally378				value = val.Obj.Decl.(*ast.ValueSpec).Values[0].(*ast.BasicLit).Value379			case (*ast.SelectorExpr):380				// when the length is a const defined in an external package381				usedPkg, err := importer.Default().Import(fmt.Sprintf("%s", val.X))382				if err != nil {383					return nil, p.errorf(v.Len.Pos(), "unknown package in array length: %v", err)384				}385				ev, err := types.Eval(token.NewFileSet(), usedPkg, token.NoPos, val.Sel.Name)386				if err != nil {387					return nil, p.errorf(v.Len.Pos(), "unknown constant in array length: %v", err)388				}389				value = ev.Value.String()390			}391			x, err := strconv.Atoi(value)392			if err != nil {393				return nil, p.errorf(v.Len.Pos(), "bad array size: %v", err)394			}395			ln = x396		}397		t, err := p.parseType(pkg, v.Elt)398		if err != nil {399			return nil, err400		}401		return &model.ArrayType{Len: ln, Type: t}, nil402	case *ast.ChanType:403		t, err := p.parseType(pkg, v.Value)404		if err != nil {405			return nil, err406		}407		var dir model.ChanDir408		if v.Dir == ast.SEND {409			dir = model.SendDir410		}411		if v.Dir == ast.RECV {412			dir = model.RecvDir413		}414		return &model.ChanType{Dir: dir, Type: t}, nil415	case *ast.Ellipsis:416		// assume we're parsing a variadic argument417		return p.parseType(pkg, v.Elt)418	case *ast.FuncType:419		in, variadic, out, err := p.parseFunc(pkg, v)420		if err != nil {421			return nil, err422		}423		return &model.FuncType{In: in, Out: out, Variadic: variadic}, nil424	case *ast.Ident:425		if v.IsExported() {426			// `pkg` may be an aliased imported pkg427			// if so, patch the import w/ the fully qualified import428			maybeImportedPkg, ok := p.imports[pkg]429			if ok {430				pkg = maybeImportedPkg.Path()431			}432			// assume type in this package433			return &model.NamedType{Package: pkg, Type: v.Name}, nil434		}435		// assume predeclared type436		return model.PredeclaredType(v.Name), nil437	case *ast.InterfaceType:438		if v.Methods != nil && len(v.Methods.List) > 0 {439			return nil, p.errorf(v.Pos(), "can't handle non-empty unnamed interface types")440		}441		return model.PredeclaredType("interface{}"), nil442	case *ast.MapType:443		key, err := p.parseType(pkg, v.Key)444		if err != nil {445			return nil, err446		}447		value, err := p.parseType(pkg, v.Value)448		if err != nil {449			return nil, err450		}451		return &model.MapType{Key: key, Value: value}, nil452	case *ast.SelectorExpr:453		pkgName := v.X.(*ast.Ident).String()454		pkg, ok := p.imports[pkgName]455		if !ok {456			return nil, p.errorf(v.Pos(), "unknown package %q", pkgName)457		}458		return &model.NamedType{Package: pkg.Path(), Type: v.Sel.String()}, nil459	case *ast.StarExpr:460		t, err := p.parseType(pkg, v.X)461		if err != nil {462			return nil, err463		}464		return &model.PointerType{Type: t}, nil465	case *ast.StructType:466		if v.Fields != nil && len(v.Fields.List) > 0 {467			return nil, p.errorf(v.Pos(), "can't handle non-empty unnamed struct types")468		}469		return model.PredeclaredType("struct{}"), nil470	case *ast.ParenExpr:471		return p.parseType(pkg, v.X)472	}473	return nil, fmt.Errorf("don't know how to parse type %T", typ)474}475// importsOfFile returns a map of package name to import path476// of the imports in file.477func importsOfFile(file *ast.File) (normalImports map[string]importedPackage, dotImports []string) {478	var importPaths []string479	for _, is := range file.Imports {480		if is.Name != nil {481			continue482		}483		importPath := is.Path.Value[1 : len(is.Path.Value)-1] // remove quotes484		importPaths = append(importPaths, importPath)485	}486	packagesName := createPackageMap(importPaths)487	normalImports = make(map[string]importedPackage)488	dotImports = make([]string, 0)489	for _, is := range file.Imports {490		var pkgName string491		importPath := is.Path.Value[1 : len(is.Path.Value)-1] // remove quotes492		if is.Name != nil {493			// Named imports are always certain.494			if is.Name.Name == "_" {495				continue496			}497			pkgName = is.Name.Name498		} else {499			pkg, ok := packagesName[importPath]500			if !ok {501				// Fallback to import path suffix. Note that this is uncertain.502				_, last := path.Split(importPath)503				// If the last path component has dots, the first dot-delimited504				// field is used as the name.505				pkgName = strings.SplitN(last, ".", 2)[0]506			} else {507				pkgName = pkg508			}509		}510		if pkgName == "." {511			dotImports = append(dotImports, importPath)512		} else {513			if pkg, ok := normalImports[pkgName]; ok {514				switch p := pkg.(type) {515				case duplicateImport:516					normalImports[pkgName] = duplicateImport{517						name:       p.name,518						duplicates: append([]string{importPath}, p.duplicates...),519					}520				case importedPkg:521					normalImports[pkgName] = duplicateImport{522						name:       pkgName,523						duplicates: []string{p.path, importPath},524					}525				}526			} else {527				normalImports[pkgName] = importedPkg{path: importPath}528			}529		}530	}531	return532}533type namedInterface struct {534	name *ast.Ident535	it   *ast.InterfaceType536}537// Create an iterator over all interfaces in file.538func iterInterfaces(file *ast.File) <-chan namedInterface {539	ch := make(chan namedInterface)540	go func() {541		for _, decl := range file.Decls {542			gd, ok := decl.(*ast.GenDecl)543			if !ok || gd.Tok != token.TYPE {544				continue545			}546			for _, spec := range gd.Specs {547				ts, ok := spec.(*ast.TypeSpec)548				if !ok {549					continue550				}551				it, ok := ts.Type.(*ast.InterfaceType)552				if !ok {...

1import (2func main() {3	var i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 interface{}4	iter := iterInterfaces(i1, i2, i3, i4, i5, i6, i7, i8, i9, i10)5	for iter.Next() {6		fmt.Println(iter.Value())7	}8}9import "reflect"10type iterInterfaces []interface{}11func (i iterInterfaces) Next() bool {12	return len(i) > 013}14func (i iterInterfaces) Value() interface{} {15}16func iterInterfaces(values ...interface{}) iterInterfaces {17	return iterInterfaces(values)18}19import (20type iterInterfaces []interface{}21func (i iterInterfaces) Next() bool {22	return len(i) > 023}24func (i iterInterfaces) Value() interface{} {25}26func iterInterfaces(values ...interface{}) iterInterfaces {27	return iterInterfaces(values)28}29import (30type iterInterfaces []interface{}31func (i iterInterfaces) Next() bool {32	return len(i) > 033}34func (i iterInterfaces) Value() interface{} {35}36func iterInterfaces(values ...interface{}) iterInterfaces {37	return iterInterfaces(values)38}39import (40type iterInterfaces []interface{}41func (i iterInterfaces) Next() bool {42	return len(i) > 043}44func (i iterInterfaces) Value

1import (2type I interface {3    M()4}5func main() {6    i = &T{"Hello"}7    describe(i)8    i.M()9}10type T struct {11}12func (t *T) M() {13    fmt.Println(t.S)14}15func describe(i I) {16    fmt.Printf("(%v, %T)17}18(&{Hello}, *main.T)19(&{Hello}, *main.T)20(&{Hello}, *main.T)21(&{Hello}, *main.T)22(&{Hello}, *main.T)23(&{Hello}, *main.T)24(&{Hello}, *main.T)25(&{Hello}, *main.T)26(&{Hello}, *main.T)27(&{Hello}, *main.T)28(&{Hello}, *main.T)29(&{Hello}, *main.T)30(&{Hello}, *main.T)31(&{Hello}, *main.T)32(&{Hello}, *main.T)33(&{Hello}, *main.T)34(&{Hello}, *main.T)35(&{Hello}, *main.T)36(&{Hello}, *main.T)37(&{Hello}, *main.T)38(&{Hello}, *main.T)39(&{Hello}, *main.T)40(&{Hello}, *main.T)

1import "fmt"2func main() {3    var s1 = []interface{}{"a", "b", "c"}4    var s2 = []interface{}{1, 2, 3}5    var s3 = []interface{}{4, 5, 6}6    var s4 = []interface{}{7, 8, 9}7    var s5 = []interface{}{10, 11, 12}8    var s6 = []interface{}{13, 14, 15}9    var s7 = []interface{}{16, 17, 18}10    var s8 = []interface{}{19, 20, 21}11    var s9 = []interface{}{22, 23, 24}12    var s10 = []interface{}{s1, s2, s3}13    var s11 = []interface{}{s4, s5, s6}14    var s12 = []interface{}{s7, s8, s9}15    var s13 = []interface{}{s10, s11, s12}16    var s14 = []interface{}{s13, s13, s13}17    var s15 = []interface{}{s14, s14, s14}18    var s16 = []interface{}{s15, s15, s15}19    var s17 = []interface{}{s16, s16, s16}20    var s18 = []interface{}{s17, s17, s17}21    var s19 = []interface{}{s18, s18, s18}22    var s20 = []interface{}{s19, s19, s19}23    var s21 = []interface{}{s20, s20, s20}24    var s22 = []interface{}{s21, s21, s21}25    var s23 = []interface{}{s22, s22, s22}26    var s24 = []interface{}{s23, s23, s23}27    var s25 = []interface{}{s24, s24, s24}28    var s26 = []interface{}{s25, s25, s25}29    var s27 = []interface{}{s26, s26, s26}30    var s28 = []interface{}{s

1import "fmt"2func main() {3   var intSlice = []int{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }4   var stringSlice = []string{ "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten" }5   var floatSlice = []float64{ 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10 }6   var mainClass = new(mainClass)7   fmt.Println("Printing integer slice")8   mainClass.iterInterfaces(intSlice)9   fmt.Println("Printing string slice")10   mainClass.iterInterfaces(stringSlice)11   fmt.Println("Printing float slice")12   mainClass.iterInterfaces(floatSlice)13}14import "fmt"15func main() {16   var intSlice = []int{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }17   var stringSlice = []string{ "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten" }18   var floatSlice = []float64{ 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.10 }19   var mainClass = new(mainClass)20   fmt.Println("Printing integer slice")21   mainClass.iterInterfaces(intSlice)22   fmt.Println("Printing string slice")23   mainClass.iterInterfaces(stringSlice)24   fmt.Println("Printing float slice")25   mainClass.iterInterfaces(floatSlice)26}27import "fmt"28func main() {29   var intSlice = []int{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }

1import (2func main() {3    m := new(Main)4    m.iterInterfaces()5}6import (7type Main struct {8}9type Inter interface {10    abstractMethod()11}12func (m *Main) abstractMethod() {13    fmt.Println("Abstract method of interface Inter")14}15func (m *Main) iterInterfaces() {16    i := new(Inter)17    (*i).abstractMethod()18}

1import "fmt"2func main() {3    m := map[string]int{"one": 1, "two": 2}4    fmt.Println("Iterating over the interfaces:")5    for _, v := range []interface{}{i, s, f, m} {6        fmt.Println(v)7    }8}9import "fmt"10func main() {11    m := map[string]int{"one": 1, "two": 2}12    fmt.Println("Iterating over the interfaces:")13    for _, v := range []interface{}{i, s, f, m} {14        fmt.Println(v)15    }16}17import "fmt"18func main() {19    m := map[string]int{"one": 1, "two": 2}20    fmt.Println("Iterating over the interfaces:")21    for _, v := range []interface{}{i, s, f, m} {22        fmt.Println(v)23    }24}25import "fmt"26func main() {27    m := map[string]int{"one": 1, "two": 2}28    fmt.Println("Iterating over the interfaces:")29    for _, v := range []interface{}{i, s, f, m} {30        fmt.Println(v)31    }32}33import "fmt"34func main() {35    m := map[string]int{"one": 1, "two": 2}36    fmt.Println("Iterating over the interfaces:")37    for _, v := range []interface{}{i, s, f, m} {38        fmt.Println(v

1import "fmt"2func main() {3    var i interface{}4    i = &main{}5    iterInterfaces(i)6}7import (8func iterInterfaces(i interface{}) {9    v := reflect.ValueOf(i)10    for v.Kind() == reflect.Ptr {11        v = v.Elem()12    }13    if v.Kind() != reflect.Struct {14    }15    for i := 0; i < v.NumField(); i++ {16        f := v.Field(i)17        if f.Kind() == reflect.Interface {18            fmt.Println("field", v.Type().Field(i).Name, "is interface")19            if f.IsNil() {20                fmt.Println("interface is nil")21            } else {22                fmt.Println("interface is not nil")23                iterInterfaces(f.Interface())24            }25        } else if f.Kind() == reflect.Struct {26            fmt.Println("field", v.Type().Field(i).Name, "is struct")27            iterInterfaces(f.Interface())28        } else if f.Kind() == reflect.Ptr {29            fmt.Println("field", v.Type().Field(i).Name, "is ptr")30            iterInterfaces(f.Interface())31        } else {32            fmt.Println("field", v.Type().Field(i).Name, "is", f.Kind())33        }34    }35}36import "fmt"37func main() {38    var i interface{}39    i = &main{}40    iterInterfaces(i)41}42import (43func iterInterfaces(i interface{}) {44    v := reflect.ValueOf(i)45    for v.Kind() == reflect.Ptr {46        v = v.Elem()47    }48    if v.Kind() != reflect.Struct {49    }

1import (2type myStruct struct {3}4func main() {5	iterInterfaces(a)6}7func iterInterfaces(i interface{}) {8	s := reflect.ValueOf(i)9	for i := 0; i < s.NumField(); i++ {10		f := s.Field(i)11		fmt.Println(f)12	}13}14f := s.Field(i).Elem()15fmt.Println(f)16f := s.Field(i).Interface()17fmt.Println(f)18panic: interface conversion: interface {} is nil, not int19f := s.Field(i).Interface()20fmt.Println(f)21panic: interface conversion: interface {} is nil, not string22f := s.Field(i).Interface()23fmt.Println(f)24panic: interface conversion: interface {} is nil, not float6425f := s.Field(i).Interface()26fmt.Println(f)27panic: interface conversion: interface {} is nil, not main.myStruct28f := s.Field(i).Interface()29fmt.Println(f)30panic: interface conversion: interface {} is nil, not main.myStruct31f := s.Field(i).Interface()32fmt.Println(f)33panic: interface conversion: interface {} is nil, not main.myStruct

1import (2func main() {3	var arr = []string{"hello", "world", "how", "are", "you"}4	var mainObj = new(main)5	mainObj.iterInterfaces(arr)6}7import (8func main() {9	var arr = []string{"hello", "world", "how", "are", "you"}10	var mainObj = new(main)11	mainObj.iterInterfaces(arr)12}13import (14func main() {15	var arr = []string{"hello", "world", "how", "are", "you"}16	var mainObj = new(main)17	mainObj.iterInterfaces(arr)18}19import (20func main() {21	var arr = []string{"hello", "world", "how", "are", "you"}22	var mainObj = new(main)23	mainObj.iterInterfaces(arr)24}25import (26func main() {27	var arr = []string{"hello", "world", "how", "are", "you"}28	var mainObj = new(main)29	mainObj.iterInterfaces(arr)30}31import (32func main() {

1import (2func main() {3	var i interface{} = 54	fmt.Println(reflect.TypeOf(i))5	fmt.Println(reflect.ValueOf(i))6	fmt.Println(reflect.TypeOf(i).Kind())7	fmt.Println(reflect.ValueOf(i).Kind())8	fmt.Println(reflect.ValueOf(i).Type())9	fmt.Println(reflect.TypeOf(i).Name())10	fmt.Println(reflect.ValueOf(i).Type().Name())11}12import (13func main() {14	var i interface{} = 515	fmt.Println(reflect.TypeOf(i))16	fmt.Println(reflect.ValueOf(i))17	fmt.Println(reflect.TypeOf(i).Kind())18	fmt.Println(reflect.ValueOf(i).Kind())19	fmt.Println(reflect.ValueOf(i).Type())20	fmt.Println(reflect.TypeOf(i).Name())