Go Variable Assignment with Interfaces and Dynamic Types

I have a script that pulls from a different data source depending on the user input with a general interface and a type for each data source. Each data source then has a method to get the meta data for that particular source. I'm struggling a bit understanding the idomatic Go implementation to switch types depending on input.

This example does not compile, but it was the version that best illustrates what I want to do:

type Post interface {
  GetMetadata() bool
}

type YouTubeVideo struct {
  ID            string
  Title         string
  ChannelID     string
  ChannelTitle  string
  PublishedAt   string
}

func (ig *YouTubeVideo) GetMetadata() bool {
  // ...
}

type InstagramPic struct {
  ID            string
  ShortCode     string
  Type          string
  Title       string
  PublishedAt   string
}

func (ig *InstagramPic) GetMetadata() bool {
  // ...
}

func main() {
  var thePost Post

  switch domain {
  case "youtube":
	thePost = new(YouTubeVideo)
	thePost.ID = pid
  case "instagram":
	thePost = new(InstagramPic)
	thePost.ShortCode = pid
  }

  thePost.GetMetadata()

  fmt.Println(thePost.title)
}

Depending on the details, I believe your structure is in general sound. But some more understanding is required.

With an interface, such as Post, you can only access the methods defined for the interface (GetMetadata() in this case). The value stored in the interface, eg. the *YouTubeVideo or *InstagramPic) cannot be accessed without a type assertion or type switch.

Therefore, it is not possible to get the title using thePost.title.

Getting a Post's field value

Here you have two alternatives (three if you count "type assertions"):

1) Add access to properties through Interface methods

type Post interface {
  GetMetadata() bool
  Title() string // Added Title method
}

func (ig *YouTubeVideo) Title() string {
  return ig.Title     
}

...

fmt.Println(thePost.Title())

2) Access the properties with a type switch

switch v := thePost.(type) {
case *YouTubeVideo:
	fmt.Println(v.ChannelTitle)
case *InstagramPic:
	fmt.Println(v.PublishedAt)
}

Alternative 1) is useful if all types that implements a Post also should give access to a certain property. 2) allows you to access fields specific for that type, but it requires then a case for each type.

Setting a Post's field value

Just like when getting, you can't directly set an Interface value's fields. In you case you should first set the desired fields before storing it in the interface:

v := new(YouTubeVideo)
v.ID = pid
thePost = v // Store the *YouTubeVideo in thePost

Or a bit shorter:

thePost = &YouTubeVideo{ID: pid}

Final note

With some tuning, your structure should work using interfaces and type switches. But exactly how to best structure it is dependent on your specific situation which we have too little information about.

To get a better understanding on how to use interfaces, I recommend reading: Effective Go: Interfaces and Types