code: func GoToLuaProxy(L *lua.State, a interface{}) {
  	visited := newVisitor(L)
  	goToLua(L, a, true, visited)
  	visited.close()
  }
docs: // 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.