LuneScript は型推論をサポートしています。

変数にセットする初期値から、その変数の型を決定できます。 これによって、次のように型を指定せずに変数を宣言できます。

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

この場合、 val1 は int, val2 は real, val3 は str であるとして処理します。

型を明示する必要があるのは、次の場合などです。

• nilable 型の変数の初期値に nil を設定する

  let mut val:int! = nil;
  

• リスト型や、マップ型の変数の初期値に、 immediate な空の値 ([], {} など)を設定する

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

• 次のようなクラス型の変数にサブクラスのインスタンスを設定する際、変数の型をスーパークラスの型としたい場合

  let val:Super = new Sub();
  

初期化していない変数を参照すると、コンパイルエラーになります。

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

上記の print() では、未初期化の val にアクセスしていますが、 ここでコンパイルエラーになります。

// @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 では、 同名の変数宣言を禁止しています。

ここで同名とは、同一スコープ内での同名に限らず、 アクセス可能なスコープ内での同名を指します。

具体的には、次の変数宣言はエラーとなります。

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

この仕様は賛否別れると思いますが、安全側に振ってこの仕様にしています。

宣言した変数は、ローカル変数として処理されます。

外部のモジュールに公開したい場合は、次のように pub を付加して宣言します。

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

外部公開されている変数にアクセスする場合、次のように import を使用します。

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

ここで、 SubModule は pub let val = 1; を宣言している LuneScript のモジュール(SubModule.lns)です。

この val にアクセスする場合、SubModule.val とすることでアクセスできます。

変数を外部モジュールに公開する方法としては pub が基本ですが、 もう一つ global を使うことも出来ます。

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

pub と global の違いは、 名前空間の違いです。

次の例を見ると分かり易いと思いますが、 これは上記 val1, val2 を外部からアクセスしているサンプルです。

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

val1 は、 SubModule.val1 として SubModule の名前空間内の変数としてアクセスしますが、 val2 は、最上位の名前空間の変数としてアクセスします。

LuneScript だけでシステムを開発する際は、 global を利用することはまず無いと思います(というか global の使用を避けるべきです)が、 他の Lua モジュールと連携して処理する際は、 global を使用せざるを得ないこともあると思います。

そのような互換性を保つことを目的として、 global をサポートしています。

なお global の制約として、次があります。

「global 宣言した変数は、 その変数を宣言したモジュールを import した時に有効になる。」

例えば次の例では val2 は、 SubModule になんの関係もなく存在しているように見えますが、

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

次の場合 SubModule を import していないため、val2 は存在しないのでエラーとなります。

// @lnsFront: skip
print( val2 );

また外部公開する変数には、次の制約があります。

「外部公開する変数は、スクリプトの最上位のスコープに宣言しなければならない」

例えば、次の val2 は最上位のスコープではないためエラーとなります。

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

単に宣言した変数は、変更禁止の変数として扱います。

例えば、次の val = 2 はエラーとなります。

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

可変な変数(mutable)とする場合、次のように mut で宣言します。

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

なお、次のように immutable の変数を宣言した後に初期値を代入することもできます。

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

ただし、次のように初期値を代入した後にさらに値をセットするとエラーになります。

// @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 は、 Lua と同じで関数の戻り値に複数の値を返せます。

この戻り値を変数宣言の初期値とするには、次のように宣言します。

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

mut は各変数名の前に宣言します。

宣言したローカル変数に対し、 値を設定した後にその変数を参照しないと、警告を出力します。 一方で、クラスのメンバや、関数の引数などはアクセスチェックの対象になりません。

次のサンプルは、 多値返却の 1 番目の値を使用せずに 2 番目の値だけを使用する場合の例です。 この場合、1 番目の値を格納している val1 が使用されていないことを警告します。

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

このような多値返却の 2 番目以降の値にアクセスするためだけに宣言した変数に対して、 警告を出さないようにするには、次のように '_' シンボルを使用します。

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

なお、 '_' シンボルで宣言した変数にはアクセスできません。 アクセスするとエラーになります。

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

アクセスチェックは、変数の値を更新した後にも行なう。

例えば次の場合、 val1 は警告される。

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

これは、 val1 に 1 をセット後に print( val1 ) で val1 を参照しているが、 次に val1 = 2 で val1 を更新後に val1 を参照していないためである。

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

次のシンボルは、特殊な値を指します。

なお、 __mod__, __func__ が展開する名前の書式は、 将来変更する可能性 があります。