func MakeChan(typ Type, buffer int) Value {
	return value_MakeChan(typ, buffer)
}
MakeChan creates a new channel with the specified type and buffer size.
package reflect
import (
	"reflect"
	"unsafe"
)
type Type = *rtype
type rtype struct{}
type flag uintptr
const (
	flagKindWidth        = 5  
	flagKindMask    flag = 1<<flagKindWidth - 1
	flagStickyRO    flag = 1 << 5
	flagEmbedRO     flag = 1 << 6
	flagIndir       flag = 1 << 7
	flagAddr        flag = 1 << 8
	flagMethod      flag = 1 << 9
	flagMethodShift      = 10
	flagRO          flag = flagStickyRO | flagEmbedRO
)
type Kind = reflect.Kind
const (
	Invalid Kind = iota
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	Array
	Chan
	Func
	Interface
	Map
	Ptr
	Slice
	String
	Struct
	UnsafePointer
)
const (
	_             SelectDir = iota
	SelectSend               
	SelectRecv               
	SelectDefault            
)
type StructTag = reflect.StructTag
type ChanDir = reflect.ChanDir
const (
	RecvDir ChanDir             = 1 << iota  
	SendDir                                  
	BothDir = RecvDir | SendDir              
)
type MapIter = reflect.MapIter
type ValueError = reflect.ValueError
type SliceHeader = reflect.SliceHeader
type StringHeader = reflect.StringHeader
type SelectCase struct {
	Dir  SelectDir  
	Chan Value      
	Send Value      
}
type SelectDir = reflect.SelectDir
type Value struct {
	typ Type
	ptr unsafe.Pointer
	flag
}
type Method struct {
	Name    string
	PkgPath string
	Type  Type   
	Func  Value  
	Index int    
}
type StructField struct {
	Name string
	PkgPath string
	Type      Type       
	Tag       StructTag  
	Offset    uintptr    
	Index     []int      
	Anonymous bool       
}
func ArrayOf(count int, elem Type) Type {
	return arrayOf(count, elem)
}
func ChanOf(dir ChanDir, t Type) Type {
	return chanOf(dir, t)
}
func FuncOf(in, out []Type, variadic bool) Type {
	return funcOf(in, out, variadic)
}
func MapOf(key, elem Type) Type {
	return mapOf(key, elem)
}
func PtrTo(t Type) Type {
	return ptrTo(t)
}
func SliceOf(t Type) Type {
	return sliceOf(t)
}
func StructOf(fields []StructField) Type {
	return structOf(fields)
}
func TypeOf(v interface{}) Type {
	value := (*Value)(unsafe.Pointer(&v))
	return value.typ
}
func TypeID(v interface{}) uintptr {
	return uintptr(unsafe.Pointer(TypeOf(v)))
}
func valueOf(v interface{}) Value {
	if v == nil {
		return Value{}
	}
	valueLayout := (*Value)(unsafe.Pointer(&v))
	value := Value{}
	value.typ = valueLayout.typ
	value.ptr = valueLayout.ptr
	f := flag(value.typ.Kind())
	if ifaceIndir(value.typ) {
		f |= flagIndir
	}
	value.flag = f
	return value
}
func TypeAndPtrOf(v interface{}) (Type, unsafe.Pointer) {
	value := (*Value)(unsafe.Pointer(&v))
	return value.typ, value.ptr
}
func ValueOf(v interface{}) Value {
	escape(v)
	return valueOf(v)
}
func ValueNoEscapeOf(v interface{}) Value {
	return valueOf(v)
}
func ToReflectType(t Type) reflect.Type {
	return toRT(t)
}
func ToReflectValue(v Value) reflect.Value {
	return toRV(v)
}
func ToType(t reflect.Type) Type {
	return toT(t)
}
func ToValue(v reflect.Value) Value {
	return toV(v)
}
func Copy(dst, src Value) int {
	return value_Copy(dst, src)
}
func DeepEqual(x, y interface{}) bool {
	return reflect.DeepEqual(x, y)
}
func Swapper(slice interface{}) func(i, j int) {
	return reflect.Swapper(slice)
}
func Append(s Value, x ...Value) Value {
	return value_Append(s, x...)
}
func AppendSlice(s, t Value) Value {
	return value_AppendSlice(s, t)
}
func Indirect(v Value) Value {
	return value_Indirect(v)
}