Go creating a structure dynamically

This script does not work. How may I create a new struc dynamically by getting the types of incoming variables like proc.ReadStat ? (type of proc.ReadStat is *linux.Stat as shown by reflect.TypeOf() )

package main
import (
"fmt"
"reflect"
//"html"
"log"
"net/http"
//"time"
"encoding/json"
"github.com/gorilla/mux"
proc "github.com/c9s/goprocinfo/linux"
)
func sysinfo(w http.ResponseWriter, r *http.Request) {
sstat, _ := proc.ReadStat("/proc/stat")
sdiskstats, _ := proc.ReadDiskStats("/proc/diskstats")
sloadavg, _ := proc.ReadLoadAvg("/proc/loadavg")
smeminfo,_ := proc.ReadMemInfo("/proc/meminfo")
smounts, _ := proc.ReadMounts("/proc/mounts")
snetstat, _ := proc.ReadNetStat("/proc/net/netstat")
sdevstat, _ := proc.ReadNetworkStat("/proc/net/dev")
ssockstat, _ := proc.ReadSockStat("/proc/net/sockstat")
svmstat, _ := proc.ReadVMStat("/proc/vmstat")
t   /* type Info interface {
stat      *linux.Stat
diskstats []linux.DiskStat
loadavg   *linux.LoadAvg
meminfo   *linux.MemInfo
mounts    *linux.Mounts
netstat   *linux.NetStat
devstat   []linux.NetworkStat
sockstat  *linux.SockStat 
vmstat    *linux.VMStat
}*/
type Info struct {
stat       reflect.TypeOf(sstat)
diskstats  reflect.TypeOf(sdiskstats)
loadavg    reflect.TypeOf(sloadavg)
meminfo    reflect.TypeOf(smeminfo)
mounts     reflect.TypeOf(smounts)
netstat    reflect.TypeOf(snetstat)
devstat    reflect.TypeOf(sdevstat)
sockstat   reflect.TypeOf(ssockstat)
vmstat     reflect.TypeOf(svmstat)
}
type infos []Info
infos := info{
stat : sstat,
diskstats : sdiskstats,
loadavg : sloadavg,
meminfo : smeminfo,
mounts : smounts,
netstat : snetstat,
devstat : sdevstat,
sockstat : ssockstat,
vmstat : svmstat,
}
json.NewEncoder(w).Encode(infos)
}
func main() {
router := mux.NewRouter().StrictSlash(true)
router.HandleFunc("/", sysinfo)
log.Fatal(http.ListenAndServe(":8080", router))
}

In statically typed languages (Go is one of them) type info (of variables, fields etc.) have to be present and compile-time, so you can't do something like:

type Info struct {
stat       reflect.TypeOf(sstat)
}

Because reflect.TypeOf() is a function which will run at run-time. If you don't know the type of something, you may use interface{}, but then you won't get any compile-time type checking from the compiler.

Since you just want to marshal the results, you can use interface{} as the type of the fields. Also note that field names must be exported (must start with a capital letter) in order to be included in JSON output.

So try the following:

type Info struct {
Stat       interface{}
Diskstats  interface{}
Loadavg    interface{}
Meminfo    interface{}
Mounts     interface{}
Netstat    interface{}
Devstat    interface{}
Sockstat   interface{}
Vmstat     interface{}
}
type infos []Info
infos := info{
Stat : sstat,
Diskstats : sdiskstats,
Loadavg : sloadavg,
Meminfo : smeminfo,
Mounts : smounts,
Netstat : snetstat,
Devstat : sdevstat,
Sockstat : ssockstat,
Vmstat : svmstat,
}
json.NewEncoder(w).Encode(infos)

Note that you could also just use a simple map[string]interface{}:

infos := map[string]interface{}{
"stat" : sstat,
"diskstats" : sdiskstats,
"loadavg" : sloadavg,
"meminfo" : smeminfo,
"mounts" : smounts,
"netstat" : snetstat,
"devstat" : sdevstat,
"sockstat" : ssockstat,
"vmstat" : svmstat,
}
json.NewEncoder(w).Encode(infos)

Also please do not forget about and do not omit error handling: store returned errors and check whether they are nil!