nil は、 Lua の nil と同じです。

LuneScript では null も利用できます。

null は nil の alias です。

null のサポートにより、 LuneScript で JSON をそのまま扱うことができます。

LuneScript は、整数と実数を分けて扱います。

これにより 10/3 は 3 となり、 10/3.0 は 3.3333… となります。

型名はそれぞれ次の通りです。

// @lnsFront: ok
let val:int = 1;      // 整数 int
let val2:real = 1.5;  // 実数 real

// @lnsFront: ok
print( ?a ); // 97  (0x61)

// @lnsFront: ok
print( 1 & 3 == 1 );

// @lnsFront: ok
print( 1 | 2 == 3 );

// @lnsFront: ok
print( 1 ~ 3 == 2 );

// @lnsFront: ok
print( 1 |<< 2 == 4 );

// @lnsFront: ok
print( 0x10 |>> 2 == 4 );

// @lnsFront: ok
print( ~2 == 0xfffffffd );

" か ' で囲むと文字列になります。 "" 内では ' が使用でき、 '' 内では " が使用できます。

なお、 "", '' は改行を含めることはできません。 改行を含める場合は "\n" とします。

\n を使用せずに複数行の文字列を定義するには ``` を使用します。 `````` 内の \n は、改行ではなくそのまま \n として文字列になります。

文字列内の特定位置の文字を取得するには、 [N] を使用します。 ここで指定する N は、文字列先頭が 1 を示します。

// @lnsFront: ok
let txt = "abc";
print( txt[ 2 ] );  // 98

N が文字列長を越えた場合の動作は、 未定義 です。

文字列長は # で取得します。

// @lnsFront: ok
print( #"abc" ); // 3

型名は次の通り str です。

// @lnsFront: ok
let val:str = "abc"; // 文字列 str

// @lnsFront: ok
print( "abc" .. "efg" );  // abcdefg

// @lnsFront: ok
print( "%s %d %d" ("abc", 1, 2) ); // abc 1 2

true, false をもちます。

型名は、次の通り bool です。

// @lnsFront: ok
let val:bool = true; // bool

リストは値を追加、削除可能な型です。

// @lnsFront: ok
let mut list:List<int> = [];
list.insert( 1 ); // [ 1 ]
list.insert( 2 ); // [ 1, 2 ]
list.insert( 3 ); // [ 1, 2, 3 ]
list.remove(); // [ 1, 2 ]
print( list[1] ); // 1

リストの要素には [index] でアクセスします。 リストの先頭の index は 1 です。 リストの範囲外をアクセスした場合の動作は 未定義 です。

当初の LuneScript は、 lua のトランスコンパイラとして開発を始めたため、 lua との互換性を重視し index を 1 からにしましたが、 今となってはこれは失敗だったと思っています。。

リストの長さを取得するのは # です。 例えば #list は、 リスト型の変数 list の長さを取得します。

値の追加は Lua と同じで insert(), 削除は remove() です。

型名は、次の通り List<T> です。 ここで T は、リストが保持する要素の型を示します。

// @lnsFront: ok
let val:List<int> = [1,2];

Map のリテラルは JSON フォーマットを拡張したフォーマットです。

次のように JSON フォーマットを扱えます。

// @lnsFront: ok
let map = {
   "val1": 1,
   "val2": 2,
   "val3": 3
};
print( map.val1, map.val2, map.val3 ); // 1 2 3

次の点で JSON と違います。

• キーと値に nil 以外の全ての値を使用できる

// @lnsFront: ok
let mut test:Map<int,int> = {};
let map = {
   1: "val1",
   2.0: "val2",
   test: "val3"
};
print( map[ 1 ], map[ 2.0 ], map[ test ] ); // val1 val2 val3

また、 null を nil の alias としているため、 JSON そのものを扱うことが出来ます。

// @lnsFront: ok
let mut map:Map<str,int> = {};
map[ "abc" ] = 1;
map.xyz = 10;

Map の要素には [key] でアクセスします。 key の型が str の場合、 .key としてもアクセスできます。

例えば、次の [ "abc" ] と .abc は同じ要素にアクセスするため、 次の例の print は true を出力します。

// @lnsFront: skip
print( map[ "abc" ] == map.abc ); // true

なお、マップに対して # 演算子は使用できません。

Map の型名は、次の通り Map<K,V> です。 ここで K はキーの型、V はキーに紐付ける値の型です。

// @lnsFront: ok
let val:Map<str,int> = { "abc":123 };

// @lnsFront: ok
let val:Map<str,int> = { "abc":123 };
val.abc = nil;
let mut total = 0;
foreach _ in val {
    total = total + 1;
}
print( total ); // 1

// @lnsFront: ok
let val:Map<str,int> = { "abc":123 };
fn func( work:int! ) {
   val.abc = work;  // warrning
}
func( 1 );

// @lnsFront: ok
let map = {
   1: "val1",
   1.0: "val2",
};
print( map[ 1 ], map[ 1.0 ] );

// @lnsFront: ok
let mut map:Map<&List<int>,str> = {};
let list1 = [ 1 ];
let list2 = [ 1 ];
map[ list1 ] = "aaa";
print( map[ list1 ], map[ list2 ] );  // aaa nil

// @lnsFront: ok
let map = {
   "val1": 1,
   "val2": 2,
   "val3": 3
};
print( map.val1, map.val2, map.val3 ); // 1 2 3

print( map.val1 +1 )

値の集合を扱います。

詳しくは次の記事を参照してください。

../set/

値の組み合わせを扱います。

詳しくは次の記事を参照してください。

../tuple/

List, Array, Map は generics 対応しています。

例えば、そえぞれ次のように宣言します。

// @lnsFront: ok
let list:List<int> = [];  // int を要素に持つリスト
let array:Array<real> = [@];  // real を要素に持つ配列
let map:Map<str,int> = {}; // str をキー、int を値に持つマップ

// @lnsFront: ok
let list = [ 1, 2, 3 ];
let map = { "A": 10, "B": 11, "C": 12 };

リストやマップなどのコレクションは、上記のようにリテラルを宣言できます。 この時生成される リスト、マップの型は、 構成する値によって決まります。

コレクションのコンストラクタで利用される値が全て同じ型なら、 そのコレクションの型は、その値の型となります。

例えば上記サンプルの [ 1, 2, 3 ] は List<int> となります。

コレクションのコンストラクタで利用される値が異なれば、 そのコレクションの型は stem となります。

具体的には、次のようになります。

// @lnsFront: ok
let list1 = [ 1, 2, 3 ];			// List<int>
let list2 = [ 'a', 'b', 'c' ];			// List<str>
let list3 = [ 'a', 1, 'c' ];			// List<stem>
let map1 = { "A": 10, "B": 11, "C": 12 };	// Map<str,int>
let map2 = { "A": 10, "B": 11, "C": 12 };	// Map<str,int>
let map3 = { "a": 'z', "b": 'y', "c": 'x' };	// Map<str,str>
let map4 = { "a": 1, "b": 'Z' };		// Map<str,stem>

継承関係のある複数クラスを混在したコレクションのコンストラクタは、 型推論が解決できずにエラーすることがあります。

その場合は、型を明示してください。

次のサンプルを示します。

// @lnsFront: error
class Test {
}
class Sub extend Test {
}
{
   let mut val1 = [ [ new Test() ], [ new Sub() ] ]; // error
   let mut val2:List<List<Test>> = [ [ new Test() ], [ new Sub() ] ]; // ok
   let mut val3 = [ [ new Test() ], [ new Test() ] ]; // ok
   let mut val4 = [ [ new Sub() ], [ new Sub() ] ]; // ok
}

ここで、型推論を利用している val1 はエラーになります。 一方で、型を明示している val2 は OK です。 val3, val4 は、クラスを混在していないため、型推論できます。

LuneScript は enum に対応しています。

詳細は次のリンク先の記事を参照してください。

../enum/

LuneScript は Lua のコードを実行できます。 Lua コードの実行結果は、 int, real, bool, str に関しては内部的に変換を行ないますが それ以外の値は変換せずに Lua の値として処理します。

その Lua の値を保持するのが Luaval です。

詳細は以下を参照してください。

../lua/

stem は、nil 以外の全ての値を保持できる型です。

LuneScript は、静的型付け言語であり、 想定する型と異なる値を与えらた場合はコンパイルエラーします。

対して stem 型は、nil 以外の全ての型を扱える型なので、 nil 以外のどのような値を与えられてもコンパイルエラーしません。

stem! は nil を含む全ての値を扱える型です。 Lua の変数そのものと考えて問題ありません。

なお、一旦 stem 型に変換すると元の型に戻すにはキャストが必要です。

キャストについては、次のリンク先を参照してください。

../cast/

form は関数オブジェクトを扱う型です。

関数については後述します。