[Go] check if struct field is exported

godoc: https://golang.org/pkg/reflect/#Value.CanInterface

if !reflect.ValueOf(strct).Field(i).CanInterface() {
   continue
}

[Go] select through slice of channels from reflect.Select

Reference:
https://golang.org/pkg/reflect/#Select

e.g https://play.golang.org/p/Ul-e3DoVv5K

package main

import (
 "context"
 "fmt"
 "math/rand"
 "reflect"
 "time"
)

func main() {
 const numberOfTest = 10
 soc := make([]reflect.SelectCase, numberOfTest)
 channels := make([]chan int, numberOfTest)

 for idx := range channels {
  channels[idx] = make(chan int, 1)
 }

 for i := range soc {
  soc[i] = reflect.SelectCase{
   Dir:  reflect.SelectRecv,
   Chan: reflect.ValueOf(channels[i]),
  }
 }

 ctx, cancel := context.WithCancel(context.Background())

 go func() {
  send := make(chan struct {
   int
   reflect.Value
   bool
  }, 1)

  receive := send

  go func() {
   for {
    // block call, could use a circuit breaker,
    // e.g https://github.com/sony/gobreaker
    idx, val, ok := reflect.Select(soc)

    send <- struct {
     int
     reflect.Value
     bool
    }{idx, val, ok}
   }
  }()

  for {
   select {
   case <-ctx.Done():
    fmt.Println("bye~")
    return
   case payload := <-receive:
    fmt.Printf("idx: %d, value: %v, bool: %t\n",
     payload.int,
     payload.Value,
     payload.bool)
   }
  }
 }()

 go func() {
  for {
   for idx := range channels {
    channels[idx] <- rand.Intn(100)
   }

   time.Sleep(3 * time.Second)
  }

 }()

 time.Sleep(10 * time.Second)
 cancel()
 time.Sleep(3 * time.Second)
}

[Go] Awkward use of reflection

I would say the usage is a bit awkward, rule of thumb, unless necessary, reflect takes lot's of runtime speed.
Don't Do It.

package main

import (
 "fmt"
 "reflect"
)

type A struct{ Name string }
type B struct{ Age int }
type C struct{ Address string }

func Merge(a interface{}, b interface{})( d interface{}) {
 aType := reflect.TypeOf(a)
 if aType.Kind() != reflect.Struct {
  panic("a is not a struct")
 }

 bType := reflect.TypeOf(b)
 if bType.Kind() != reflect.Struct {
  panic("b is not a struct")
 }

 var fields []reflect.StructField
 for i:=0 ; i< aType.NumField(); i++{
   fields =append(fields, aType.Field(i))
 }
 for i:=0 ; i< bType.NumField(); i++{
   fields =append(fields, bType.Field(i))
 }

 dType := reflect.StructOf(fields)
 dVal := reflect.Indirect(reflect.New(dType))


 aVal := reflect.ValueOf(a)
 bVal := reflect.ValueOf(b)
 

 for i := 0; i < aType.NumField(); i++ {
  dVal.FieldByName(aType.Field(i).Name).Set(aVal.Field(i))
 }
 for i := 0; i < bType.NumField(); i++ {
  dVal.FieldByName(bType.Field(i).Name).Set(bVal.Field(i))
 }
 
 d = dVal.Interface()
  
 return 
}

func main() {
 a, b, c := A{"John"}, B{42}, C{"World"}

 d1 := Merge(a, b)
 d2 := Merge(a, c)
 d3 := Merge(b, c)

 fmt.Printf("%#v\n",d1)
 fmt.Printf("%#v\n",d2)
 fmt.Printf("%#v\n",d3)
}

Output:
struct { Name string; Age int }{Name:"John", Age:42}
struct { Name string; Address string }{Name:"John", Address:"World"}
struct { Age int; Address string }{Age:42, Address:"World"}

[Go] interesting read of Eli Bendersky's "Does a concrete type implement an interface in Go?"

Eli Bendersky has post an interesting article titled
"Does a concrete type implement an interface in Go?"


I really do love seeing C++ experts playing with other languages from their deep understanding of C/C++/Assembly :-)


Go's interface stores embedded data's type information, RTTI in C++, a pointer to v-table minus offset is type information, plus offset are pointers to member functions(index honors declared sequence).

Go's interface stores embedded data act as this pointer in C++, while calling the member functions, copying the embedded data as first parameter into member functions.

Thus, if embedded data is pointer type, then copy the pointer into the member functions.

Alas, if embedded data is instance of the data type, then copy the instance into the member functions.

Go's interface implement:
https://github.com/golang/go/blob/56131cbd1d61ec446e10dfe72a96f329ed3d952a/src/go/types/type.go#L244

Thus, Go's interface type provides an extra layer of abstraction for interface exchanges.

Go: https://godbolt.org/z/U2WqDC

package main

import "fmt"

type fun struct {
}

func (f *fun) run() {
 fmt.Println("stateless member function call.")
}

type I interface {
 run()
}

func main() {
 I((*fun)(nil)).run()
}

C++: https://godbolt.org/z/YWAXze

#include <iostream>

struct fun {
    void run()
    {
        using std::cout;
        using std::endl;
        cout << "stateless member function call." << endl;
    }
};

int main()
{
    static_cast<fun*>(nullptr)->run();
}

Reference:
A book about the internals of the Go programming language
https://github.com/teh-cmc/go-internals

Go 1.1 Function Calls - Russ Cox, February 2013
https://docs.google.com/document/d/1bMwCey-gmqZVTpRax-ESeVuZGmjwbocYs1iHplK-cjo/pub

Go Data Structures: Interfaces, Russ Cox, December 1, 2009.
https://research.swtch.com/interfaces

Go Interfaces, Ian Lance Taylor
https://www.airs.com/blog/archives/277

[golang] reflection quick note
http://vsdmars.blogspot.com/2019/01/golang-reflection-quick-note.html

[Go] reflection quick note

Reference:
https://blog.golang.org/laws-of-reflection

Retrospection is time consuming thus taking a note :-P


As with languages, reflection is based on type system.
Sadly, nowadays, the most strong typed language C++ does not have
a standard reflection system.

------

In Go, even the type refer to same underlying type, can not be assigned to

each other without a conversion.

C++

using INT = int;

INT i1 = 42;
int i2 = i1;

Golang

package main
type INT int

func main() {
 var i1 INT = 42
 var i2 int = int(i1)
 _ = i2
}

Understanding how Golang's interface type being implemented is essential to understand the Golang's reflection system.
i.e anonymous interface type it's type is always:
interface {}
It's storing value's type at run-time varies, and it's type is always interface{}

(Figure 1)

(Figure 2)

Tips

In Golang, when doing type inspection, if conversion failed, the left hand side type is default valued:

// if !ok, v is int's default value, which is 0
v, ok := any.(int)

// if !ok, v is interface_1's default value, which is nil
v, ok := any.(interface_1)

and this failed at run-time if conversion failed:

// run-time error: panic: interface conversion: interface {} is int64, not int
v := any.(int)

// run-time error: panic: interface conversion: interface {} is interface_2,
// not interface_1, which lack member functions.
v := any.(interface_1) 

When assigning/converting interface variable to interface variable, it's internal value has been assigned, the interface related function's index(ptr to member functions) has been assigned.

Law of reflection

1. Reflection goes from interface value to reflection object. (Always)

Reflection is a mechanism to examine the type and value pair stored inside an interface variable.

2 types to access interface's value/type pair:

reflect.Type

reflect.Value

2 functions to get the Type and Value type instance from an interface type instance:

reflect.TypeOf

reflect.ValueOf

reflect.Value:

• getter and setter operate's on the largest value type of the same set of types.
  e.g.
  int -> int64
  
  Thus to get the real type's value, we have to shrink and converted to the value's real type (i.e it's Kind).
  e.g.
  // v.Uint() returns the largest value type: uint64
  // and the real type is uint8 thus we shrink converted back to uint8
  x = uint8(v.Uint())
• .Type() give the value's type
• .Kind() give type it stores: Uint, Float64, Slice, etc.
  For Go 1.14 we have 26 types.
  This describes the underlying type, not the alias type name.
  e.g.
  //Kind() returns int kind
  type INT int
• .Float() retrieve it's value.
• .Int()  retrieve it's value.
• ...
• .String() repr

    

reflect.Type:

    .Kind() gives the type it stores: Uint, Float64, Slice, etc.

    .String() repr

2. Reflection goes from reflection object to interface value.

reflect.Value:

• .Interface() interface{}
  Packs the value back into interface{} and returns.
  e.g
  // y will have type float64.
  y := v.Interface().(float64)
  
  // fmt.Print... unpack interface internal value
  fmt.Println(v.Interface())

3. To modify a reflection object, the value must be settable.

e.g.

var x float64 = 3.4

// the interface{} has a copy of value x.
v := reflect.ValueOf(x)

// Error: will panic.  It's not setting the x, but the copy of it.
v.SetFloat(7.1)

reflect.Value:

• .CanSet() // bool, can the underlying value being set?
• .Elem() Return's the value (in Value type) of the *p points to.

e.g.

var x float64 = 3.4

// Note: take the address of x.
p := reflect.ValueOf(&x)

// *float64
fmt.Println("type of p:", p.Type())

// false?! Why? Because we do not want to set p, but *p
fmt.Println("settability of p:", p.CanSet())

Thus, we need .Elem() to dereference *p, i.e .Elem() dereference the *p, which is the address of x in the above example(Refer to Figure 1) :

v := p.Elem()

// true
fmt.Println("settability of v:", v.CanSet())

Same in C/C++, as long as we have the struct instance's address, we can modify it's fields.
e.g.

type T struct {
    A int        // Must be exported, thus upper case.
    B string    // Must be exported, thus upper case.
}

t := T{23, "skidoo"}
s := reflect.ValueOf(&t).Elem()

typeOfT := s.Type()

for i := 0; i < s.NumField(); i++ {
    f := s.Field(i)
    fmt.Printf("%d: %s %s = %v\n", i,
        typeOfT.Field(i).Name, f.Type(), f.Interface())
}

out:

0: A int = 23

1: B string = skidoo