Started to work on a Lua wrapper. Please provide feedback & guidance

[Gabi]

I need a Lua 5.2.2 wrapper, So I started working on one..
I am new to D so probably there is a lot of room for 
improvements..
Any feedback is welcome..
import std.stdio:writeln, writefln;
import std.exception:enforce;
import std.conv;
import std.string;


alias void lua_State;
alias long lua_Integer;
alias double lua_Number;

enum LUA_OK = 0;
enum LUA_MULTRET = -1;

extern (C)
{

    lua_State *luaL_newstate ();
    void lua_close (lua_State *L);
    void luaL_openlibs (lua_State *L);

    int lua_gettop (lua_State *L);
    void lua_settop (lua_State *L, int index);

    int luaL_loadstring (lua_State *L, const char *s);
    int lua_pcallk (lua_State *L, int nargs, int nresults, int 
errfunc, int ctx, void*);

    void lua_setglobal (lua_State *L, const char *name);
    void lua_getglobal (lua_State *L, const char *name);
    void lua_getfield (lua_State *L, int index, const char *k);

    lua_Number lua_tonumberx (lua_State *L, int index, int 
*isnum);
    lua_Integer lua_tointegerx (lua_State *L, int index, int 
*isnum);
    const char *lua_tolstring (lua_State *L, int index, size_t 
*len);

    const char *lua_pushstring (lua_State *L, const char *s);
    void lua_pushinteger (lua_State *L, lua_Integer n);
    void lua_pushnumber (lua_State *L, lua_Number n);
}

class LuaException:Exception
{
     this (string msg)
     {
         super(msg);
     }
}

class Lua
{
private:
    lua_State* _luaState;
    void _pushArg(long arg)
    {
          lua_pushinteger(_luaState, arg);
    }
    void _pushArg(int arg)
    {
          lua_pushinteger(_luaState, to!long(arg));
    }
    void _pushArg(double arg)
    {
          lua_pushnumber(_luaState, arg);
    }
    void _pushArg(float arg)
    {
          lua_pushnumber(_luaState, to!double(arg));
    }
    void _pushArg(string arg)
    {
          lua_pushstring(_luaState, arg.ptr);
    }
    void _pushArg(const char* arg)
    {
        lua_pushstring(_luaState, arg);
    }

    void _runFun(ARGS...)(string packageName, string funName, 
ARGS args)
    {

        if(packageName.length == 0 || packageName == ".")
        {
            lua_getglobal(_luaState, funName.ptr);
        }
        else
        {
            lua_getglobal(_luaState, packageName.ptr);
            lua_getfield(_luaState, -1, funName.ptr);
        }

        //Push arguments
        foreach(arg; args)
        {
            _pushArg(arg);
        }
        int rv = lua_pcallk(_luaState, cast(int)args.length, 1, 
0, 0, null );
        enforce(rv == LUA_OK, new LuaException("runFun:lua_pcallk 
failed"));
    }

public:
    this()
    {
        _luaState = luaL_newstate();
        enforce(_luaState != null, new 
LuaException("luaL_newstate() failed"));
        luaL_openlibs(_luaState);
    }

    ~this()
    {
        close();
    }

    void close()
    {
        if(_luaState != null)
            lua_close(_luaState);
    }

    @property
    lua_State* luaState()
    {
        return _luaState;
    }
    /*
     * Load function
     * Throw LuaException on error
     */
    void loadFun(string funBody)
    {
        int rv = luaL_loadstring(_luaState, funBody.ptr);
        enforce(rv == LUA_OK, new 
LuaException("loadFun:luaL_loadstring failed"));
        rv = lua_pcallk(_luaState, 0, LUA_MULTRET, 0, 0, null);
        enforce(rv == LUA_OK, new 
LuaException("loadFun:lua_pcallk failed"));
    }
    /*
     * Load function and give it a name.
     * funBody should be anonymous function like 
"function(x,y)..end"
     * Throw LuaException on error
     */
    void loadFun(string funName, string funBody)
    {
        loadFun(funName ~ "=" ~funBody);
    }
    /*
     * Execute the given function and return it rv
     * packageName can be empty or "." for global scope function
     * Throw LuaException on error
     */
    T runFun(T:double, ARGS...)(string packageName, string 
funName, ARGS args)
    {
        int top = lua_gettop(_luaState);
        _runFun(packageName, funName, args);
        scope(exit) lua_settop(_luaState, top);
        return lua_tonumberx(_luaState, -1, null);
    }

    T runFun(T:long, ARGS...)(string packageName, string funName, 
ARGS args)
    {
        int top = lua_gettop(_luaState);
        _runFun(packageName, funName, args);
        scope(exit) lua_settop(_luaState, top);
        return lua_tointegerx(_luaState, -1, null);
    }

    T runFun(T:string, ARGS...)(string packageName, string 
funName, ARGS args)
    {
        int top = lua_gettop(_luaState);
        scope(exit) lua_settop(_luaState, top);
        _runFun(packageName, funName, args);

        const char* rv = lua_tolstring(_luaState, -1, null);
        return to!string(rv);
    }

    T runFun(T:const char*, ARGS...)(string packageName, string 
funName, ARGS args)
    {
        int top = lua_gettop(_luaState);
        scope(exit) lua_settop(_luaState, top);
        _runFun(packageName, funName, args);
        return lua_tolstring(_luaState, -1, null);
    }
}

unittest
{
    string fn1 =
    """
    function add(x, y)
        return (x+y)
    end
    """;

    string fn2 =
    """
    function (x, y)
        return (x..y)
    end
    """;

    Lua l = new Lua();
    l.loadFun(fn1);
    assert(l.runFun!double(".", "add", 6, 3) == 9);

    assert(l.runFun!long(".", "add", 3, -3) == 0L);

    l.loadFun("concat", fn2);
    assert(l.runFun!(string)(".", "concat", "AAA", "BBB") == 
"AAABBB");
}