func GoToLuaProxy(L *lua.State, a interface{}) {
	visited := newVisitor(L)
	goToLua(L, a, true, visited)
	visited.close()
}
func GoToLuaProxy(L *lua.State, a interface{}) {
	visited := newVisitor(L)
	goToLua(L, a, true, visited)
	visited.close()
}
// GoToLuaProxy is like GoToLua but pushes a proxy on the Lua stack when it makes sense.
//
// A proxy is a Lua userdata that wraps a Go value.
//
// Proxies have several uses:
//
// - Type checking in Go function calls, so variable of user-defined type are
// always profixied.
//
// - Reflexive modification of the Go data straight from the Lua code. We only
// allow this for compound types.
//
// - Call methods of user-defined types.
//
// Predeclared scalar types are never proxified as they have no methods and we
// only allow compound types to be set reflexively.
//
// Structs are always proxified since their type is always user-defined. If they
// they are not settable (e.g. not nested, not passed by reference, value of a
// map), then a copy is passed as a proxy (otherwise setting the fields from Lua
// would panic). This will not impact the corresponding Go value.
//
// Arrays are only proxified if they are settable (so that the user can set the
// Go value from the Lua side) or if they are of a user-defined type (method
// calls or function parameters). If the type user-defined but the array is not
// settable, then a proxy of a copy is made, just as for structs.
//
// Lua cannot dereference pointers and Go can only call methods over one level
// of indirection at maximum. Thus proxies wrap around values dereferenced up to
// the last pointer.
//
// Go functions can be passed to Lua. If the parameters require several levels
// of indirections, the arguments will be converted automatically. Since proxies
// can only wrap around one level of indirection, functions modifying the value
// of the pointers after one level of indirection will have no effect.