How to use parseType method of main Package

...172func TestParseType(t *testing.T) {173	// Prefixes are OK174	var typ dosa.ScopeType175	var err error176	typ, err = parseType("dev")177	assert.Nil(t, err)178	assert.Equal(t, dosa.Development, typ)179	typ, err = parseType("dEv")180	assert.Nil(t, err)181	assert.Equal(t, dosa.Development, typ)182	typ, err = parseType("development")183	assert.Nil(t, err)184	assert.Equal(t, dosa.Development, typ)185	typ, err = parseType("prod")186	assert.Nil(t, err)187	assert.Equal(t, dosa.Production, typ)188	typ, err = parseType("Prod")189	assert.Nil(t, err)190	assert.Equal(t, dosa.Production, typ)191	typ, err = parseType("PROD")192	assert.Nil(t, err)193	assert.Equal(t, dosa.Production, typ)194	typ, err = parseType("production")195	assert.Nil(t, err)196	assert.Equal(t, dosa.Production, typ)197	typ, err = parseType("int")198	assert.NotNil(t, err)199	// Typos200	typ, err = parseType("probuction")201	assert.NotNil(t, err)202	typ, err = parseType("deve1opment")203	assert.NotNil(t, err)204}...

...104}105func parserParams(fields []*ast.Field) (params []*param) {106	for _, field := range fields {107		p := &param{}108		p.V = parseType(field.Type)109		if field.Names == nil {110			params = append(params, p)111		}112		for _, name := range field.Names {113			sp := &param{}114			sp.K = name.Name115			sp.V = p.V116			sp.P = p.P117			params = append(params, sp)118		}119	}120	return121}122func parseType(expr ast.Expr) string {123	switch expr.(type) {124	case *ast.Ident:125		return expr.(*ast.Ident).Name126	case *ast.StarExpr:127		return "*" + parseType(expr.(*ast.StarExpr).X)128	case *ast.ArrayType:129		return "[" + parseType(expr.(*ast.ArrayType).Len) + "]" + parseType(expr.(*ast.ArrayType).Elt)130	case *ast.SelectorExpr:131		return parseType(expr.(*ast.SelectorExpr).X) + "." + expr.(*ast.SelectorExpr).Sel.Name132	case *ast.MapType:133		return "map[" + parseType(expr.(*ast.MapType).Key) + "]" + parseType(expr.(*ast.MapType).Value)134	case *ast.StructType:135		return "struct{}"136	case *ast.InterfaceType:137		return "interface{}"138	case *ast.FuncType:139		var (140			pTemp string141			rTemp string142		)143		pTemp = parseFuncType(pTemp, expr.(*ast.FuncType).Params)144		if expr.(*ast.FuncType).Results != nil {145			rTemp = parseFuncType(rTemp, expr.(*ast.FuncType).Results)146			return fmt.Sprintf("func(%s) (%s)", pTemp, rTemp)147		}148		return fmt.Sprintf("func(%s)", pTemp)149	case *ast.ChanType:150		return fmt.Sprintf("make(chan %s)", parseType(expr.(*ast.ChanType).Value))151	case *ast.Ellipsis:152		return parseType(expr.(*ast.Ellipsis).Elt)153	}154	return ""155}156func parseFuncType(temp string, data *ast.FieldList) string {157	var params = parserParams(data.List)158	for i, param := range params {159		if i == 0 {160			temp = param.K + " " + param.V161			continue162		}163		t := param.K + " " + param.V164		temp = fmt.Sprintf("%s, %s", temp, t)165	}166	return temp...

1import (2func main() {3	fmt.Println(reflect.TypeOf(a))4	fmt.Println(reflect.TypeOf(b))5	fmt.Println(reflect.TypeOf(c))6	fmt.Println(reflect.TypeOf(d))7}8import (9func main() {10	fmt.Println(reflect.TypeOf(a).Name())11	fmt.Println(reflect.TypeOf(b).Name())12	fmt.Println(reflect.TypeOf(c).Name())13	fmt.Println(reflect.TypeOf(d).Name())14}15import (16func main() {17	fmt.Println(reflect.TypeOf(a).Kind())18	fmt.Println(reflect.TypeOf(b).Kind())19	fmt.Println(reflect.TypeOf(c).Kind())20	fmt.Println(reflect.TypeOf(d).Kind())21}22import (23func main() {24	fmt.Println(reflect.TypeOf(a).String())25	fmt.Println(reflect.TypeOf(b).String())26	fmt.Println(reflect.TypeOf(c).String())27	fmt.Println(reflect.TypeOf(d).String())28}29import (30func main() {31	fmt.Println(reflect.TypeOf(a).String())32	fmt.Println(reflect.TypeOf(b).String())33	fmt.Println(reflect.TypeOf(c).String())34	fmt.Println(reflect.TypeOf(d).String())35}

1import (2func main() {3    var st struct{}4    var ifc interface{}5    var fn func()6    fmt.Println("Type of i is " + parseType(reflect.TypeOf(i)))7    fmt.Println("Type of s is " + parseType(reflect.TypeOf(s)))8    fmt.Println("Type of b is " + parseType(reflect.TypeOf(b)))9    fmt.Println("Type of f is " + parseType(reflect.TypeOf(f)))10    fmt.Println("Type of a is " + parseType(reflect.TypeOf(a)))11    fmt.Println("Type of m is " + parseType(reflect.TypeOf(m)))12    fmt.Println("Type of c is " + parseType(reflect.TypeOf(c)))13    fmt.Println("Type of p is " + parseType(reflect.TypeOf(p)))14    fmt.Println("Type of e is " + parseType(reflect.TypeOf(e)))15    fmt.Println("Type of st is " + parseType(reflect.TypeOf(st)))16    fmt.Println("Type of ifc is " + parseType(reflect.TypeOf(ifc)))17    fmt.Println("Type of fn is " + parseType(reflect.TypeOf(fn)))18    fmt.Println("Type of ui is " + parseType(reflect.TypeOf(ui)))19    fmt.Println("Type of ui8 is " + parseType(reflect.TypeOf(ui8)))20    fmt.Println("Type of ui16 is " + parseType(reflect.TypeOf(ui16)))21    fmt.Println("Type of ui32 is " + parseType(reflect.TypeOf(ui32)))22    fmt.Println("Type of ui64 is " + parseType(reflect.TypeOf(ui64)))23    fmt.Println("Type of i8 is

1main.parseType("1.go")2main.parseType("2.go")3main.parseType("3.go")4main.parseType("4.go")5main.parseType("5.go")6main.parseType("6.go")7main.parseType("7.go")8main.parseType("8.go")9main.parseType("9.go")10main.parseType("10.go")11main.parseType("11.go")12main.parseType("12.go")13main.parseType("13.go")14main.parseType("14.go")15main.parseType("15.go")

1import (2type main struct {3}4func (m main) parseType() {5    fmt.Println("Type1:", reflect.TypeOf(m.type1))6    fmt.Println("Type2:", reflect.TypeOf(m.type2))7}8func main() {9    m := main{"Type1", "Type2"}10    m.parseType()11}12import (13type main struct {14}15func (m main) parseType() {16    fmt.Println("Type1:", reflect.TypeOf(m.ty

1import (2func main() {3	fmt.Println("Hello, playground")4	mainClass.parseType("string")5}6import (7func main() {8	fmt.Println("Hello, playground")9	mainClass.parseType("string")10}11import (12func main() {13	fmt.Println("Hello, playground")14	mainClass.parseType("string")15}16import (17func main() {18	fmt.Println("Hello, playground")19	mainClass.parseType("string")20}21import (22func main() {23	fmt.Println("Hello, playground")24	mainClass.parseType("string")25}26import (27func main() {28	fmt.Println("Hello, playground")29	mainClass.parseType("string")30}31import (32func main() {33	fmt.Println("Hello, playground")34	mainClass.parseType("string")35}36import (37func main() {38	fmt.Println("Hello, playground")39	mainClass.parseType("string")40}41import (42func main() {43	fmt.Println("Hello, playground")44	mainClass.parseType("string")45}46import (47func main() {48	fmt.Println("Hello, playground")49	mainClass.parseType("string")50}

1import (2func main() {3	fmt.Println("Type of x:", reflect.TypeOf(x))4	parseType(x)5}6func parseType(i interface{}) {7	fmt.Println("Type of i:", reflect.TypeOf(i))8}9type Person struct {10}11func main() {12	fmt.Println("Type of p:", reflect.TypeOf(p))13	parseType(p)14}

1import (2func main() {3    inputArray := strings.Split(input, ",")4    for _, value := range inputArray {5        parsedValue, err := parseType(value, "int")6        if err != nil {7            fmt.Println(err)8        } else {9            intSlice = append(intSlice, parsedValue.(int))10        }11    }12    fmt.Println(intSlice)13}14func parseType(value string, parseType string) (interface{}, error) {15    switch parseType {16        return strconv.Atoi(value)17        return strconv.ParseFloat(value, 64)18        return strconv.ParseBool(value)