v := reflect.ValueOf(TargetStruct)
 f := reflect.Indirect(v).FieldByName(field)

v := reflect.ValueOf(TargetSlice)
for i := 0; i < v.Len(); i++ {
    allElem[i] = s.Index(i)
}

// StructFieldByName returns the struct field with the given name.
// It returns the nil if no field was found.
// It panics if input data Kind is not struct.
func StructFieldByName(structData interface{}, name string) interface{} {
    // unpack Struct
    e := (*emptyInterface)(unsafe.Pointer(&structData))
    startPointer := e.word

    // check flag
    valueMetadataFlag := e.typ.kind
    if valueMetadataFlag == 0 {
        panic("invalied reflect.Value.Type")
    }
    
    // please input a struct type data 
    if valueMetadataFlag != structKind {
        panic("Field of non-struct type ")
    }

    // pick up target field
    var targetStructField *structField
    tt := (*structType)(unsafe.Pointer(e.typ))
    for i := range tt.fields {
        tf := &tt.fields[i]
        if tf.name.name() == name {
            targetStructField = tf
        }
    }
    if targetStructField == nil {
        return nil
    }

    // repack target field
    var packed interface{}
    pe := (*emptyInterface)(unsafe.Pointer(&packed))
    pe.typ  = targetStructField.typ
    pe.word = add(startPointer, targetStructField.offset(), "same as non-reflect &v.field")
    return packed
}

// Get all elements from an interface (slice type)
// SliceAllElements returns the all elements from an interface (slice type).
// It returns the nil if no field was found.
// It panics if input data Kind is not slice.
func SliceAllElements(sliceData interface{}) []interface{} {
    // unpack Struct
    e := (*emptyInterface)(unsafe.Pointer(&sliceData))

    // check flag
    valueMetadataFlag := e.typ.kind
    if valueMetadataFlag == 0 {
        panic("invalied reflect.Value.Type")
    }

    // please input a slice type data 
    if valueMetadataFlag != sliceKind {
        panic("non-slice type ")
    }
    
    s := (*UnsafeSlice)(e.word)

    // check slice len and init a container for return 
    if s.Len < 1 { // an empty slice
        return nil
    }

    // pickup and return
    allElements := make([]interface{}, s.Len)
    tt := (*sliceType)(unsafe.Pointer(e.typ))
    typ := tt.elem
    for i := 0; i < s.Len; i++ {
        element := arrayAt(s.Data, i, typ.size, "i < s.Len")
        var packed interface{}
        pe := (*emptyInterface)(unsafe.Pointer(&packed))
        pe.typ  = typ
        pe.word = element
        allElements[i] = packed
    }
    return allElements
}