How to read an slice of like []interface{} in Go?

I have something like this:

a := []interface{}{}
b := []interface{}{}
type S struct {
  text string
}


s := S{"string"}
t := S{"string"}
a = append(a, s)
b = append(b, t)
a := append(a, b)

a

And now I want to read elements of a, or elements of elements.. but how?

What you want is called a type assertion. http://golang.org/ref/spec#Type_assertions

The simple example on that page is:

var x interface{} = 7  // x has dynamic type int and value 7
i := x.(int)           // i has type int and value 7`

The other thing to note is that a type assertion returns a value called ok that is true if the assertion is successful. Here's a simple code example for your case:

a := []interface{}{}
b := []interface{}{}
type S struct {
  text string
}


s := S{"string"}
t := S{"string"}
a = append(a, s)
b = append(b, t)
a = append(a, b)

assertedS,ok := a[0].(S)
if !ok { // If this is, in fact, not a value of type S, something is wrong
    // error handling
}

fmt.Println(assertedS) // Should show you the same thing as printing s

assertedB,ok := a[1].([]interface{})
if !ok {
    //...
}

assertedT,ok := assertedB[0].(S)
if !ok {
    //...
}

fmt.Println(assertedT) // Should show you the same thing as printing t

If you don't know ahead of time which list element is what, you can iterate through it and use the "type switch". http://golang.org/ref/spec#Switch_statements

switch x.(type) {
    // cases
}

Which allows you to perform conditional behavior based on what type the stored interface{} really is.

For instance, you might use

func ExtractSlice(a []interface{}) {
  for _,x := range a {
    switch i := x.(type) {
    case S:
        fmt.Println(i)
    case []interface{}:
        ExtractSlice(i) // Recursively unpacks b once it's found within a
    }
  }
}

Do you mean this?

a := []interface{}{}
b := []interface{}{}
type S struct {
    text string
}
s := S{"string"}
t := S{"string"}
a = append(a, s)
b = append(b, t)
a = append(a, b)
for _, v := range a {
    switch v.(type) {
    case S:
        fmt.Println("S", v)
    default:
        fmt.Println("Slice", v)
    }
}

This code example may help:

package main

import "fmt"

func main() {
	a := []interface{}{}
	b := []interface{}{}
	type S struct {
		text string
	}

	s := S{"string s"}
	t := S{"string t"}
	a = append(a, s)
	b = append(b, t)
	a = append(a, b)

	for _, v := range a {
		fmt.Println(v)
	}
}

but be aware that you've defined a and b as slices of interfaces. This means, that when you do a = append(a, b) you're putting the b slice after the existing a string in the a slice, and therefore when you range over a you get:

>{string s} //interface of string
[{string t}] //slice of interface of string