How to determine the element type of slice interface{}?

I have the following code to double the slice.

func doubleSlice(s []int) []int  {
  t := make([]int, len(s), (cap(s) + 1) * 2 )
  for i := range s {
    t[i] = s[i]
  }
  return t
}

I want to make the func to double any type of slice. And I need to know the element type first.

func showInterfaceItem(s interface{}) interface{} {
  if reflect.TypeOf(s).Kind() != reflect.Slice {
    fmt.Println("The interface is not a slice.")
    return
  }

  var t interface{}
  newLen := reflect.ValueOf(s).Len()
  newCap := (cap(reflect.ValueOf(s).Cap()) + 1) * 2
  t = make([]reflect.TypeOf(s), newLen, newCap)

  return t
}

The reflect.TypeOf(s) return the type of interface{}, not the type of element. How can I get the element type of slice interface?

You can use reflect.TypeOf(s).Elem()
to get the type of element of slice.

package main

import (
	"fmt"
	"reflect"
)

func doubleSlice(s interface{}) interface{} {
	if reflect.TypeOf(s).Kind() != reflect.Slice {
		fmt.Println("The interface is not a slice.")
		return nil
	}

	v := reflect.ValueOf(s)
	newLen := v.Len()
	newCap := (v.Cap() + 1) * 2
	typ := reflect.TypeOf(s).Elem()
	
	t := reflect.MakeSlice(reflect.SliceOf(typ), newLen, newCap)
	reflect.Copy(t, v)
	return t.Interface()
}

func main() {
	xs := doubleSlice([]string{"foo", "bar"}).([]string)
	fmt.Println("data =", xs, "len =", len(xs), "cap =", cap(xs))

	ys := doubleSlice([]int{3, 1, 4}).([]int)
	fmt.Println("data =", ys, "len =", len(ys), "cap =", cap(ys))
}

The output will be:

data = [foo bar] len = 2 cap = 6
data = [3 1 4] len = 3 cap = 8

Check it in: Go Playground

This is doable in golang and takes me whole day to discover the pattern.

Firstly, we want to get a pointer of slice to make gorm happy, which is has type "*[]Obj". To achieve that in golang, we can create a make wrapper like so:

func makeWrapper(cap uint) interface{} {
	arr:= make([]Sth, 0, cap)
	return &arr
}

Notice that, we can't directly reference the maked value, which might be the book keeping data need to have a stack space to store.

//Not working example
func makeWrapper(cap uint) interface{} {
	return &(make([]Sth, 0, cap))
}

And as the answer before, the reflect.MakeSlice(reflect.SliceOf(typ), 0, capacity).Interface() returns interface{[]Sth}. (the typ here is refer to reflect.TypeOf(Sth{}), which equiv to typ == reflect.TypeOf(v))

Thus we need to create a return object of *[]Sth and the value inside is a slice []Sth with capacity. After understanding the objective, we can have this code:

package main

import (
	"reflect"
)

type Sth struct {
	a, b string
}
func main() {
	af:= createSlice(Sth{})
	arr := makeWrapper(10).(*[]Sth)
	println(reflect.TypeOf(arr).String())

    // equiv to makeWrapper, but we do it via reflection
	arr = af(10).(*[]Sth)
	println(reflect.TypeOf(arr).String())
}

func makeWrapper(cap uint) interface{} {
	arr:= make([]Sth, 0, cap)
	return &arr
}

func createSlice(v interface{}) func(int) interface{} {
	var typ reflect.Type
	if reflect.ValueOf(v).Kind() == reflect.Ptr {
		typ = reflect.ValueOf(v).Elem().Type()
	} else if  reflect.ValueOf(v).Kind() == reflect.Struct {
		typ = reflect.TypeOf(v)
	} else {
		panic("only support instance of struct or pointer of that instance")
	}

	return func(capacity int) interface{}{
        // create the outer object saves our slice
		outerObj:=reflect.New(reflect.SliceOf(typ))
        // create the slice and save it to return
		outerObj.Elem().Set(reflect.MakeSlice(reflect.SliceOf(typ), 0, capacity))
        // retrive the interface of outer object
		return outerObj.Interface()
	}
}