Transpiling the above code to Lua and running it will output:

fib_lua( step ) = 24157817: step = 37: time = 5.69
fib_lns( step ) = 24157817: step = 37: time = 5.38

This shows the calculation result and calculation time of fib_lua() and fib_lns() respectively.

Looking at this, you can see that the execution time of function fib_lua() loaded by Lua and function fib_lns() of Lns takes almost the same time.

This is a natural result. This is because when LuneScript is converted to Lua, fib_lns() written in LuneScript and fib_lua() written in Lua are almost the same Lua code.

When the above code is transcompiled to Lua, the code looks like this:

--miniGo.lns
local _moduleObj = {}
local __mod__ = '@miniGo'
local _lune = require( "lune.base.runtime2" )
if not _lune2 then
   _lune2 = _lune
end
local step = 37
local code = [==[
local function fib ( n )
   if n < 2 then return n end
   return fib(n - 2) + fib(n - 1)
end
return fib
]==]
local function loadLua( txt )
   local loaded = _lune.unwrap( _lune.loadstring52( txt ))
   local fib = _lune.unwrap( loaded(  ))
   return fib
end
local fib_lua = loadLua( code )
do
   local prev = os.clock(  )
   print( string.format( "%s = %d: step = %d: time = %g", "fib_lua( step )", fib_lua( step ), step, os.clock(  ) - prev) )
end
local function fib_lns( num )
   if num < 2 then
      return num
   end
   return fib_lns( num - 2 ) + fib_lns( num - 1 )
end
do
   local prev = os.clock(  )
   print( string.format( "%s = %d: step = %d: time = %g", "fib_lns( step )", fib_lns( step ), step, os.clock(  ) - prev) )
end
return _moduleObj

Here's an excerpt from the notable fib_lns() function definition:

local function fib_lns( num )
   if num < 2 then
      return num
   end
   return fib_lns( num - 2 ) + fib_lns( num - 1 )
end

As you can see, fib_lns() and fib_lub() have equivalent code.

So it's no surprise that fib_lns() and fib_lua() take about the same amount of time.

On the other hand, when transpiling to go , the execution result is:

fib_lua( step ) = 24157817: step = 37: time = 6.07
fib_lns( step ) = 24157817: step = 37: time = 0.34

You can see that fib_lns() takes about 1/18 less time than fib_lua().

Here is the result of transcompiling to go:

// This code is transcompiled by LuneScript.
package lnsc
import . "lnsc/lune/base/runtime_go"
var init_miniGo bool
var miniGo__mod__ string
var miniGo_step LnsInt
var miniGo_code string
var miniGo_fib_lua *Lns_luaValue
type miniGo_fibFunc_1003_ func (arg1 LnsInt) LnsInt
// 14: decl @miniGo.loadLua
func miniGo_loadLua_1009_(txt string) *Lns_luaValue {
    var loaded *Lns_luaValue
    loaded = Lns_unwrap( Lns_car(Lns_getVM().Load(txt, nil))).(*Lns_luaValue)
    var fib LnsAny
    fib = Lns_unwrap( Lns_car(Lns_getVM().RunLoadedfunc(loaded,Lns_2DDD([]LnsAny{}))[0]))
    return fib.(*Lns_luaValue)
}

// 36: decl @miniGo.fib_lns
func miniGo_fib_lns_1025_(num LnsInt) LnsInt {
    if num < 2{
        return num
    }
    return miniGo_fib_lns_1025_(num - 2) + miniGo_fib_lns_1025_(num - 1)
}

func Lns_miniGo_init() {
    if init_miniGo { return }
    init_miniGo = true
    miniGo__mod__ = "@miniGo"
    Lns_InitMod()
    miniGo_step = 37
    miniGo_code = "local function fib ( n )   if n < 2 then return n end   return fib(n - 2) + fib(n - 1)endreturn fib"
    miniGo_fib_lua = miniGo_loadLua_1009_(miniGo_code)
    {
        var prev LnsReal
        prev = Lns_getVM().OS_clock()
        Lns_print([]LnsAny{Lns_getVM().String_format("%s = %d: step = %d: time = %g", []LnsAny{"fib_lua( step )", Lns_getVM().RunLoadedfunc(miniGo_fib_lua,Lns_2DDD(miniGo_step))[0].(LnsInt), miniGo_step, Lns_getVM().OS_clock() - prev})})
    }
    
    {
        var prev LnsReal
        prev = Lns_getVM().OS_clock()
        Lns_print([]LnsAny{Lns_getVM().String_format("%s = %d: step = %d: time = %g", []LnsAny{"fib_lns( step )", miniGo_fib_lns_1025_(miniGo_step), miniGo_step, Lns_getVM().OS_clock() - prev})})
    }
    
}
func init() {
    init_miniGo = false
}

Since it is very difficult to read, the definition part of the fib_lns() function is extracted as follows.

func miniGo_fib_lns_1025_(num LnsInt) LnsInt {
    if num < 2{
        return num
    }
    return miniGo_fib_lns_1025_(num - 2) + miniGo_fib_lns_1025_(num - 1)
}

Although the function name is long, you can see that the LuneScript code is converted to go as it is. When executing a function, just call the function normally as follows.

 miniGo_fib_lns_1025_(miniGo_step)

On the other hand, Lua's fib_lua() function is loaded by miniGo_fib_lua = miniGo_loadLua_1009_(miniGo_code) with a function for executing Lua code, and when executing it, the function is called as follows.

Lns_getVM().RunLoadedfunc(miniGo_fib_lua,Lns_2DDD(miniGo_step))

As you can see, fib_lns() and fib_lua() are completely different.

The following steps are required to transcompile and build to go.

• Generate go.mod
• Register the LuneScript runtime with go.mod
• Generate main.go
• Generate .go from .lns
• Update go.mod
• go build

If you have updated .lns, repeat the process starting with "Generate .go from .lns".

I will explain each step.

$ go mod init test # <--- test は環境に合せて指定してください

$ go get github.com/ifritJP/LuneScript/src@latest

$ lnsc hoge.lns mkmain main.go

$ lnsc hoge.lns save -langGo

$ lnsc hoge.lns save -langGo --main hoge

$ lnsc foo/bar/hoge.lns save -langGo --main foo.bar.hoge

$ go mod tidy

$ go build

$ go build -tags gopherlua

追記

Lua ライブラリのリンクを回避する方法を用意しました。

../lua_runtime

As mentioned above, LuneScript works closely with Lua. And even after transcompiling to go, it still supports that interaction.

In order for this interaction to work, the code transcompiled to go needs the lua VM to do the lua work.

To be more precise, in addition to this interaction with Lua, LuneScript also has operations that require the Lua VM. Specifically, Lua VM is used for processing macro expansion and processing some built-in functions.

That lua VM assumes the official lua-5.3.4 and links liblua5.3.so .

The go language has the advantage of being able to generate a single, environment-independent executable, but unfortunately transcompiling LuneScript to go requires linking to liblua5.3.so .

Note that not only liblua5.3.so is required at runtime, but also include files for lua-5.3.4 are required at build time.