luar.go
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()
}
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.
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 .