How to cast interface{} back into its original struct?

I need a way to dynamically cast a struct/interface back to its original object.
I can add methods / functions inside. basically I need something like this:

MyStruct  =>  Interface{}  => MyStruct

When on the final conversion I don't know anything about the original struct besides what come inside the struct, so I can't just so:

a.(MyStruct)

You need to know at least the possible types it could be. There's a couple cases, 1. You think you might know what it is. 2. You have a list of possible types it could be, 3. Your code knows nothing about the underlying types.

1. If you think you know it, you can use type assertion to convert back to the original struct type.

...

package main

import (
	"fmt"
)

type MyStruct struct {
  Thing string
}

func (s *MyStruct) Display() {
  fmt.Println(s.Thing)
}

type Thingable interface {
  Display()
}

func main() {
  s := &MyStruct{
    Thing: "Hello",
  }

  // print as MyThing
  s.Display()

  var thinger Thingable
  thinger = s

  // print as thingable interface
  thinger.Display()

  // convert thinger back to MyStruct
  s2 := thinger.(*MyStruct) // this is "type assertion", you're asserting that thinger is a pointer to MyStruct. This will panic if thinger is not a *MyStruct

  s2.Display()
}

You can see this in action here: https://play.golang.org/p/rL12Lrpqsyu

Note if you want to test the type without panicking if you're wrong, do s2, ok := thinger.(*MyStruct). ok will be true if it was successful and false otherwise.

2. if you want to test your interface variable against a bunch of types, use a switch: (scroll to bottom)

...

package main

import (
	"fmt"
	"reflect"
)

type MyStruct struct {
	Thing string
}

type MyStruct2 struct {
	Different string
}

func (s *MyStruct) Display() {
	fmt.Println(s.Thing)
}

func (s *MyStruct2) Display() {
	fmt.Println(s.Different)
}

type Thingable interface {
	Display()
}

func main() {
	s := &MyStruct{
		Thing: "Hello",
	}

	// print as MyThing
	s.Display()

	var thinger Thingable
	thinger = s

	// print as thingable interface
	thinger.Display()

	// try to identify thinger
	switch t := thinger.(type) {
	case *MyStruct:
		fmt.Println("thinger is a *MyStruct. Thing =", t.Thing)
	case *MyStruct2:
		fmt.Println("thinger is a *MyStruct2. Different =", t.Different)
	default:
		fmt.Println("thinger is an unknown type:", reflect.TypeOf(thinger))
	}
}

You can try that out here https://play.golang.org/p/7NEbwB5j6Is

3. If you really don't know anything about the underlying types, you'll have to expose the things you need through interface functions and call those. Chances are you can do this without knowing anything about the underlying type. If all else fails, you can use the reflect package to introspect your interface object and gather information about it. this is how the json package reads json text and returns populated structs—though this is an advanced topic and expect to sink a lot of time into it if you go this route. it’s best to hide reflection code inside a package with a clean interface(ie the package api).

No: as mentioned in this thread

> Go is neither covariant nor contravariant. Types are either equal or they aren't.

> You have to either take the structs apart and deal with the pieces, or use reflection.
Type assertions are only "assertions", not "coercions" of any kind.

See also this thread, which reminds us that:

> - A pointer is one kind of type.

• A struct is another kind of type.
• An integer is another kind of type.
• A floating point number is another kind of type.
• A boolean is another kind of type.

> The principle of an interface concerns the methods attached to a type T, not what type T is.

> An interface type is defined by a set of methods.
Any value that implements the methods can be assigned to an interface value of that type.

That would make the conversion from interface to concrete type quite difficult to do.