Installing LuneScript installs the lnsc command.

For information on how to use the lnsc command, please refer to the following article:

• Hello world

  • ./tutorial3.hello

LuneScript supports cross-compilation between versions of Lua. Please refer to the following article.

• Cross-compiling between Lua versions

  • ./crosscompile

Please refer to the following article for values and types handled in LuneScript.

• value

  • value

• enum edition

  • enum

Comments use C++ style. Single-line comment // and multi-line comment /* */ can be specified.

// @lnsFront: skip
// 行末までコメント
/* ここから〜
ここまでコメント*/

In principle, operators use the same ones as Lua.

Note that Lua5.3's // (truncated division) is a one-line comment in LuneScript.

In LuneScript, / between ints is automatically rounded down and divided.

Please refer to the following article for LuneScript variables.

• variable

  • variable

Please refer to the following for LuneScript control statements.

• General branch

  • branch

• Repeat syntax

  • loop

For LuneScript functions, please refer to the following.

• Functions

  • func

LuneScript is a nil-safe (NULL-safe) language.

Please refer to the following for nilable which realizes nil safety of LuneScript.

• nilable edition

  • nilable

LuneScript supports classes for object-oriented programming.

Classes in LuneScript have the following constraints:

• Does not support multiple inheritance.
• generics are not supported.

• All are overridable methods.

  • You cannot suppress overrides.

• A method with the same name with different arguments cannot be defined between inheritances.

  • The only exception is that the constructor has the same name ( __init ).

Please refer to the following article.

• Basic class

  • class1

• accessor edition

  • class2accessor

• class inheritance

  • classinherit

• class advertise

  • classadvertise

• Class override edition

  • classoverride

• Interface

  • interface

// @lnsFront: ok
pub class Super {
}
pub proto class ClassB extend Super;
pub class ClassA {
  let val: ClassB;
}
pub class ClassB extend Super{
  let val: ClassA;
}

LuneScript class instances can be converted to and from Map objects.

This is called Mapping.

Please refer to the following for Mapping.

• mapping edition

  • classmapping

LuneScript supports generics.

See below for details.

• generics edition

  • generics

It supports the nil conditional operator as an easy way to handle nilable values.

• nil conditional operator

  • nilcond

For LuneScript module management, please refer to the following.

• import/provide edition

  • import

• require/module edition

  • require

As mentioned above, files transcompiled to Lua with LuneScript can be executed as-is with the Lua command. At this time, no external module is required.

This indicates that you have included all the code necessary for processing within the transcompiled Lua code.

For example, if you transcompile the following processing code:

// @lnsFront: ok
fn func( val:int! ):int {
   return 1 + unwrap val default 0;
}

The Lua code is much longer, like this:

--mini.lns
local _moduleObj = {}
local __mod__ = 'mini'
if not _ENV._lune then
   _lune = {}
end
function _lune.unwrap( val )
   if val == nil then
      __luneScript:error( 'unwrap val is nil' )
   end
   return val
end 
function _lune.unwrapDefault( val, defval )
   if val == nil then
      return defval
   end
   return val
end

local function func( val )
   return 1 + _lune.unwrapDefault( val, 0)
end

return _moduleObj

Lines 4 to 18 are the processing required for unwrap. Note that this code is output to all Lua files.

Since this code itself is a common process, by specifying the -r option when transcompiling, you can require it as a separate module and combine common processes.

Specifically, specify the -r option as follows.

$ lua lune/base/base.lua -r src.lns save

With this -r option, the above code would be transformed into the following, much cleaner.

--mini.lns
local _moduleObj = {}
local __mod__ = 'mini'
_lune = require( "lune.base._lune" )
local function func( val )
   return 1 + _lune.unwrapDefault( val, 0)
end

return _moduleObj

Note that require( "lune.base._lune" ) will be inserted, so you need to set this module so that it can be loaded. You don't need to be aware of this if the transcompiler operates in an environment, but you need to be careful when executing the converted Lua source in some other environment.

LuneScript employs simple macros.

Links to supplementary articles will be added here.

• Introduction to Lua Transcompiler LuneScript 2

  • Introducing subfile, module and nil conditional operators
  • introduce2

• Let's have more fun with Lua's transcompiler LuneScript's modern development environment

  • Completion, syntax checking, subfile search
  • completion

For articles not linked from this page, follow them from the sidebar.