golang type assertion using reflect.Typeof()

I've tried to identify a struct with string value(name).
reflect.TypeOf returns Type.

But type assertion needs a type.

How can I casting Type to type?

Or any suggestion to handle it?

http://play.golang.org/p/3PJG3YxIyf

package main

import (
"fmt"
"reflect"
)
type Article struct {
	Id             int64       `json:"id"`
	Title          string      `json:"title",sql:"size:255"`
	Content        string      `json:"content"`
}


func IdentifyItemType(name string) interface{} {
	var item interface{}
	switch name {
	default:
		item = Article{}
	}
	return item
}

func main() {

	i := IdentifyItemType("name")
	item := i.(Article)
	fmt.Printf("Hello, item : %v\n", item)
    item2 := i.(reflect.TypeOf(i))  // reflect.TypeOf(i) is not a type
    fmt.Printf("Hello, item2 : %v\n", item2)

}

If you need to switch on the type of the outer interface{} you wont need reflection.

switch x.(type){
  case int: 
    dosomething()
}

...but if you need to switch on the type of the attributes in an interface then you can do this:

s := reflect.ValueOf(x)
for i:=0; i<s.NumValues; i++{
  switch s.Field(i).Interface().(type){
    case int: 
      dosomething()
  }
}

I haven't found a cleaner way, I'd love to know if it exists.

A type assertion, syntactically, takes a type in the parentheses, not an expression. So it is a syntax error.

You seem to be trying to do a type assertion with a value computed at runtime. Does that make sense? Let's think about what a type assertion is.

A type assertion consists of two things:

1. At compile time: It causes the resulting expression to have the desired compile-time type. The expression x.(T) has compile-time type T. This allows you to do stuff the expression that you can do with type T, which you may not be able to do with the type of x.
2. At runtime: It checks whether the value is not nil and is actually of the given type, and if not, it causes a panic.

The first part obviously doesn't make sense for a type computed at runtime. The compile-time type of the resulting expression cannot depend on something that is not known at compile-time.

The second one (runtime check) can be done with a type computed at runtime. Something like:

if reflect.TypeOf(x) != someTypeComputedAtRuntime {
    panic(42)
}

Lots of things, but basically "it doesn't work that way". The thing inside the parentheses in a type assertion needs to be a type, that is a type name or a type literal. reflect.TypeOf(i) isn't one of those, it's a method call expression. Therefore this is a syntax error. reflect.TypeOf doesn't "return a type" (which isn't really a thing you can do in Go), it returns a reflect.Type, which is an ordinary go struct that contains information about a type (i.e. sort of a meta-type).

But the more fundamental reason why it doesn't work is because it can't... Go needs to know what the type of a variable is when it's declared. Either its type is given explicitly in a var declaration, or it's inferred from the type of the initialization value in a var x = value declaration or x := value short assignment. It is not possible for the type to be unknown at compile time. Go doesn't let you write an expression that produces an undetermined type.

The very purpose of a type assertion is to take a value of an interface type (which is a kind of "box" that can hold values of multiple types, or for interface{}, any type at all) and retrieve a value of a specific concrete type. The value produced by the assertion will have the type named by the assertion, and no other. (In the case of a ,ok assignment, if the assertion fails, the variable will hold a zero value but still be of the correct type). If you could write an assertion to a type that was known only at runtime, the whole thing would fall apart, so you can't write it — it's an error.

In short, you can't use reflection to do that. You can use reflect to learn what the type of i is, you can learn that type's name, you can learn that its underlying Kind is Struct, you can enumerate the struct's fields and get the values out of them, etc... all of these are legitimate uses of reflection. But it can't give you back a variable of type MyStruct — the way to do that is i.(MyStruct).

I think what you're looking for here is a type switch.
https://tour.golang.org/methods/16

If you can handle the noise and implement an extra method which all the types implement e.g. 'Type() string', you can do something like this:

        ve := &ValidationError{}
		nf := &NotFound{}

		switch err.Type() {
		case ve.Type() :
			SendBadRequest(w, err)
		case nf.Type() :
			http.NotFound(w, r)
		default:
			SendInternalError(w, err)
		}

I think you can use ValueOf to solve this

item2 :=  reflect.ValueOf(i)
fmt.Printf("Hello, item2 : %v\n", item2)