LuneScript supports type inference.

You can determine the type of a variable from the initial value you set to it. This allows you to declare variables without specifying their type, like this:

// @lnsFront: ok
let val1 = 1; // int 
let val2 = 1.0; // real
let val3 = "abc"; // str

In this case, val1 is treated as int, val2 as real, and val3 as str.

Examples of when you need to specify the type are:

• Set the initial value of a nilable type variable to nil

let mut val:int! = nil;

• Set an immediate empty value ([], {}, etc.) to the initial value of a list type or map type variable

let mut val:List<int> = [];

• When setting a subclass instance to a class type variable such as the following, if you want the variable type to be the superclass type

let val:Super = new Sub();

Referencing an uninitialized variable will result in a compilation error.

// @lnsFront: error
{
   let val;
   print( "%s" ( val ) ); // error
}

In print() above, an uninitialized val is accessed, which causes a compilation error.

// @lnsFront: error
fn func( flag:bool )
{
   let val;
   if flag {
     val = 1;
   }
   print( val ); // error
}

// @lnsFront: ok
fn func( flag:bool )
{
   let val;
   if flag {
     val = 1;
   }
   else {
     val = 2;
   }
   print( val ); // ok
}

// @lnsFront: error
fn func( kind:int )
{
   let val;
   if kind < 10 {
      if kind > 0 {
         val = 1;
      }
      else {
         if kind == 0 {
            val = 2;
         }
         elseif kind == 1 {
            val = 3;
         }
         // ※ 
      }
   }
   else {
      val = 4;
   }
   print( val ); // error
}

// @lnsFront: error
fn func( flag:bool )
{
   let val;
   fn sub() {
      print( val ); // error
   }
   val = 1;
   sub();
}

// @lnsFront: error
fn func( flag:bool )
{
   let val;
   if flag {
      val = 1;
   }
   else {
      val = 1.0; // error
   }
}

// @lnsFront: ok
fn func( flag:bool )
{
   let val:stem; // stem 型を宣言
   if flag {
      val = 1;
   }
   else {
      val = "a";
   }
   print( val );
}

LuneScript prohibits variable declarations with the same name.

The same name here refers not only to the same name within the same scope, but also to the same name within the accessible scope.

Specifically, the following variable declaration will result in an error.

// @lnsFront: error
{
   let val = 1;
   {
      let val = 1;  // error
   }
}

I think there are pros and cons to this specification, but I'm sticking to the safe side and making it this specification.

Declared variables are treated as local variables.

If you want to publish it to an external module, declare it with pub appended like this:

// @lnsFront: ok
pub let val = 1;

If you want to access variables exposed externally, use import like this:

// @lnsFront: skip
import SubModule;
print( SubModule.val );

where SubModule is the LuneScript module (SubModule.lns) that declares pub let val = 1;.

If you want to access this val, you can access it with SubModule.val.

pub is the basic way to expose variables to external modules, but you can also use global .

// @lnsFront: ok
pub let val1 = 1;
global let val2 = 2;

The difference between pub and global is the namespace difference.

It's easy to understand if you look at the following example, but this is a sample that accesses the above val1 and val2 from the outside.

// @lnsFront: skip
import SubModule;
print( SubModule.val1 );
print( val2 );

val1 is accessed as a variable in SubModule's namespace as SubModule.val1 , but val2 is accessed as a variable in the top-level namespace.

When developing a system with only LuneScript, I don't think you should use global (or rather, you should avoid using global ), but when processing in conjunction with other Lua modules, use global I think there are times when you have to.

For that compatibility, we support global .

There are the following global constraints.

"Variables declared as global become effective when the module that declares them is imported."

For example, in the following example val2 seems to exist in SubModule without any relation,

// @lnsFront: skip
import SubModule;
print( SubModule.val1 );
print( val2 );

In the following case, an error occurs because val2 does not exist because SubModule is not imported.

// @lnsFront: skip
print( val2 );

Also, the variables to be exposed to the outside have the following restrictions.

"Variables exposed externally must be declared in the topmost scope of the script"

For example, val2 below is an error because it is not in the topmost scope.

// @lnsFront: error
pub let val = 1;
{
   pub let val2 = 1; // error
}

A variable that is simply declared is treated as a variable that cannot be changed.

For example, val = 2 below is an error.

// @lnsFront: error
let val = 1;
val = 2; // error

If you want to make it a variable variable (mutable), declare it with mut as follows.

// @lnsFront: ok
let mut val = 1;
val = 2;

It is also possible to assign an initial value after declaring an immutable variable as follows.

// @lnsFront: ok
let val;
val = 1;

However, if you set another value after assigning the initial value as follows, an error will occur.

// @lnsFront: error
let val;
val = 1;
val = 2; // error

// @lnsFront: error
let mut list1 = [1];
list1.insert( 2 ); // ok
let list2 = [1];
list2.insert( 2 ); // error

// @lnsFront: error
let list:&List<List<int>> = [[100],[]];
list[1].insert( 1 ); // ok
list.insert( [10] ); // error

// @lnsFront: error
let list1:List<int> = [1,2];
let list2:&List<int> = [1,2];
let mut list3 = [1,2];
let list4 = [1,2];
list1.insert( 3 );
list2.insert( 3 ); // error
list3.insert( 3 );
list4.insert( 3 ); // error

LuneScript is the same as Lua and can return multiple values in function return values.

To make this return value the initial value of a variable declaration, declare it like this:

// @lnsFront: skip
let val1, val2 = func();
let mut val3, mut val4 = func();

Declare mut before each variable name.

If you declare a local variable and do not refer to it after setting its value, you will get a warning. On the other hand, class members and function arguments are not subject to access checks.

The following sample is an example of using only the second value without using the first value of the multi-value return. In this case, warn that val1 containing the first value is not used.

// @lnsFront: ok
fn sub(): int, int {
   return 1, 2;
}
fn func() {
   let val1, val2 = sub(); // warning val1
   print( val2 );
}

To suppress warnings for variables declared only to access the second and subsequent values of such a multi-value return, use the '_' symbol, like this:

// @lnsFront: ok
fn sub(): int, int {
   return 1, 2;
}
fn func() {
   let _, val2 = sub(); // ok
   print( val2 );
}

Note that variables declared with the '_' symbol cannot be accessed. Accessing it will result in an error.

// @lnsFront: error
fn sub(): int, int {
   return 1, 2;
}
fn func() {
   let _, val2 = sub();
   print( _ ); // error
   print( val2 );
}

Access checks are also performed after updating the value of a variable.

For example, val1 will be warned if:

// @lnsFront: ok
fn func() {
   let mut val1 = 1;
   print( val1 );
   val1 = 2; // warning
}

This is because val1 is referenced by print( val1 ) after setting 1 to val1, but val1 is not referenced after updating val1 with val1 = 2.

// @lnsFront: ok
fn func() {
   let mut val1 = 1;
   fn sub() {
      print( val1 );
   }
   val1 = 2;
   sub();
}

The following symbols refer to special values.

Note that the format of names expanded by __mod__ and __func__ may change in the future.