func (me *Value) Copy() *Value {
	rv := &Value{
		TypeInfo:     me.TypeInfo,
		CanWrite:     me.CanWrite,
		TopValue:     me.TopValue,
		WriteValue:   me.WriteValue,
		ElemTypeInfo: me.ElemTypeInfo,
		original:     me.original,
	}
	return rv
}
Copy creates a clone of the *Value and its internal members.

If you need to create many *Value for a type T in order to Rebind(T) in a goroutine
architecture then consider creating and caching a V(T) early in your application
and then calling Copy() on that cached copy before using Rebind().
package set
import (
	"fmt"
	"reflect"
	"github.com/nofeaturesonlybugs/errors"
)
func V(arg interface{}) *Value {
	rv := &Value{}
	rv.original = arg
	var v reflect.Value
	switch tt := arg.(type) {
	case reflect.Value:
		v = tt
	default:
		v = reflect.ValueOf(arg)
	}
	if v.IsValid() {
		rv.TypeInfo = TypeCache.StatType(v.Type())
	}
	rv.WriteValue, rv.CanWrite = Writable(v)
	rv.TopValue = v
	if rv.IsMap || rv.IsSlice {
		rv.ElemTypeInfo = TypeCache.StatType(rv.ElemType)
	}
	return rv
}
type Value struct {
	TypeInfo
	CanWrite bool
	TopValue reflect.Value
	WriteValue reflect.Value
	ElemTypeInfo TypeInfo
	original interface{}
}
func (me *Value) errorUnsupported(method string) string {
	return fmt.Sprintf("%v is unsupported for original type [%T]", method, me.original)
}
func (me *Value) Append(items ...interface{}) error {
	if me == nil {
		return errors.NilReceiver()
	} else if me.Kind != reflect.Slice {
		return errors.Errorf(me.errorUnsupported("Append"))
	}
	var err error
	func() {
		defer func() {
			if r := recover(); r != nil {
				err = errors.Errorf("%v", r)
			}
		}()
		zero := reflect.Zero(me.Type)
		for _, item := range items {
			elem := reflect.New(me.ElemType)
			elemAsValue := V(elem)
			if err = elemAsValue.To(item); err != nil {
				err = errors.Go(err)
				return
			}
			zero = reflect.Append(zero, reflect.Indirect(elemAsValue.TopValue))
		}
		me.WriteValue.Set(reflect.AppendSlice(me.WriteValue, zero))
	}()
	return err
}