LuneScript とは、前述の通り Lua の気になる点をカバーする言語で、 LuneScript で開発したコードを Lua のコードに変換することが可能な トランスコンパイラです。

LuneScript は、次の特徴を持ちます。

• NULL 安全 (null safety)。
• 静的型付け言語であるため、型チェックにより単純なミスをコンパイル時に発見可能。
• 型推論により、型宣言の手間を最小化。
• generics により、型情報を保ったままの処理が可能。
• 言語の文法としてクラス定義を対応。
• パターンマッチ対応。 (match)
• 遅延ロードによるロード時間短縮。
• 構造化データと非構造化データとの相互変換。 (Mapping)
• マクロ により、ポリモーフィズム等の動的処理に頼らないデザインを実現可能。
• 変数の初期化漏れを検知

• ! 演算子による関数のエラー移譲

  • #error
• Lua と go へのトランスコンパイル。
• JSON と互換なデータ表現をサポート。
• トランスコンパイルした Lua コードは、外部ライブラリを前提とせずに単体で動作可能。
• トランスコンパイルした Lua コードは、LuneScript で書いた処理そのままが出力されるので、 性能劣化がない。
• 既存の Lua の外部モジュールを LuneScript から利用可能。

• LuneScript は Lua 上で動作し、Lua 標準モジュール以外を必要としないため、導入が簡単。

  • go 版 LuneScript を利用すると、トランスコンパイル時間を 1/20 に短縮可能。
• LuneScript から変換した Lua モジュールを、 他の Lua モジュールから利用可能。

• Lua5.1 〜 5.4 をサポート。

  • Lua5.1 については次を参照してください。
  • #crosscompile
• LuneScript はセルフホスティングで開発している。
• emacs でのコード補完に対応

• lnstags によるタグジャンプに対応

  • #lnstags
• glue コードの自動生成に対応
• Lua と C の syntax を基調としているため、学習コストが低い。

LuneScript は github で開発しています。

<https://github.com/ifritJP/LuneScript>

導入方法は次を参照してください。

• 導入編

  • #tutorial2_setup

ここでは LuneScript の仕様について説明します。

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

// @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 を使用したプロジェクトをビルドする方法については、次を参考にしてください。

• ビルド 編

  • #make

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

--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

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

--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

LuneScript の動作確認用に、Web ブラウザ上で動作する LuneScript 環境を用意しています。

#onweb

また、以降のサンプルソースには Run ボタンを持つケースがあります。 そのボタンを押すことで、そのサンプルソースを実行できます。 そして、そのソースを修正して実行することもできます。

Run ボタンを押してからサンプルを実行するまでに、 初回は数秒から 10 秒程度時間がかかります (時間はネットワーク環境、端末スペックに依存します)。 これは、ブラウザ上に Lua VM と、LuneScript コンパイラをロードするためです。

一旦ロードした後に再度実行する場合、 このロード処理が行なわれないため瞬時に実行できます。

LuneScript は、次の 2 つの提供方法を用意しています。

• 単独で実行可能なシングルバイナリの go バージョン
• Lua のスクリプトとして動作する Lua バージョン

$ git clone --depth 1 https://github.com/ifritJP/LuneScript
$ cd LuneScript/src
$ sudo docker build -t linux_lns test/docker/compose/linux/build
$ sudo docker run --rm -v $PWD:/local linux_lns cp /usr/bin/lnsc /local/lnsc

$ sudo docker build -t linux_lns test/docker/compose/linux/build --build-arg PROXY=http://proxy.hoge/

$ lua -v

$ sudo apt install lua5.3

$ git clone https://github.com/ifritJP/LuneScript.git
$ cd LuneScript/src
$ lua5.3 setup.lua -d
$ sudo make install

$ lua5.3 -e 'print( package.path )'

/usr/local/share/lua/5.3/?.lua;/usr/local/share/lua/5.3/?/init.lua;/usr/local/lib/lua/5.3/?.lua;/usr/local/lib/lua/5.3/?/init.lua;/usr/share/lua/5.3/?.lua;/usr/share/lua/5.3/?/init.lua;./?.lua;./?/init.lua

LuneScript は、emacs で開発するための emacs lisp を提供しています。

次の設定をしてください。

  (add-to-list 'load-path "my-lune-path")  ;;; clone した LuneScript のパスを指定
  (setq lns-lua-command "/usr/local/bin/lua")  ;;; lua のパス
  (require 'lns-conf)
  (require 'lns-flymake)
  (require 'lns-company-mode)
  (require 'lns-helm)

これにより、次が利用できます。

• .lns ファイルのインデント、色付け
• flymake による構文チェック
• company-mode による補完

構文チェックは flymake と flycheck をサポートしています。 flycheck を利用したい場合 lns-flymake ではなく、 lns-flycheck を require してください。

helm, company-mode, flycheck, flymake は、別途 M-x package-install してください。

LuneScript は、モジュール管理にディレクトリ階層を利用します。 よって、 LuneScript でトランスコンパイルを行なう際の カレントディレクトリは重要になります。

トランスコンパイルを行なう際のカレントディレクトリに、 次の名前のファイルを置くことで、 プロジェクトファイルとして扱います。

lune.js

特にエディタで LuneScript のソースを編集する場合、 その LuneScript ソースのプロジェクトディレクトリが何処なのか認識するために、 このファイルが検索されるので、 必ず上記ファイルを生成してください。

{}

foo/
foo/lune.js
foo/bar/
foo/bar/mod1.lns

{
    "cmd_option": [ "--valid-luaval" ]
}

Lua のモジュール管理は非常に単純なため、簡単に導入ができます。

次回は LuneScript による Hello World について紹介します。

LuneScript を導入すると、lnsc コマンドがインストールされます。

lnsc コマンドは次のように利用します。

$ lnsc src.lns exe

ここで src.lns は、 LuneScript で作成したスクリプトのパスです。 exe は lnsc のオプションで、 指定したスクリプトを実行することを意味します。

では LuneScript を使って、伝統の Hello world を実行してみましょう。

次の内容を持つファイル hello.lns を作成してください。

// @lnsFront: ok
print( "Hello world." );

そして、次のコマンドを実行します。

$ lnsc hello.lns exe

これで "Hello world" が出力されました。

これだけだと面白くもなんともないので、もう少し話を続けます。

まずは、 hello.lns を次のように少し変更します。

// @lnsFront: ok
let txt = "world";
print( "Hello %s." ( txt ) );

このスクリプトの結果も Hello world. になります。

では、次のコマンドを実行してみてください。

$ lnsc hello.lns lua

次が出力されたと思います。

--hello.lns
local _moduleObj = {}
local __mod__ = 'hello'
if not _lune then
   _lune = {}
end
local txt = "world"
print( string.format( "Hello %s.", txt) )
return _moduleObj

これは hello.lns を Lua に変換したコードです。

なんだかゴチャゴチャしていますが、 print( string.format( "Hello %s.", txt) ) が出力されているのが分かると思います。

これは、 LuneScript で書いた print( "Hello %s." ( txt ) ) が、 Lua にトランスコンパイルする際に print( string.format( "Hello %s.", txt) ) に展開されていることを示します。

では、次のコマンドを実行してください。

$ lnsc hello.lns save

これによって、 hello.lua ファイルが作成されました。 hello.lua ファイルの内容は、先ほど出力した Lua のコードと同じものです。

では、次のコマンドで hello.lua を実行してください。

$ lua5.3 hello.lua

Hello world. が出力されているでしょう。 Lua にトランスコンパイルしたコードは、 LuneScript に依存しない Lua のコードになります。

最初に実行した lnsc hello.lns exe は、 LuneScript のスクリプトをトランスコンパイルし、実行まで行なうコマンドです。

次に実行した lnsc hello.lns lua は、 LuneScript のスクリプトをトランスコンパイルし、Lua コードを標準出力するコマンドです。

最後に実行した lnsc hello.lns save は、 LuneScript のスクリプトをトランスコンパイルし、Lua コードを保存するコマンドです。

このドキュメントでは exe を利用しつつ、 変換後のコードを確認する際は save コマンドを利用していきます。

LuneScript では、 区切り記号 ; が必須です。 次のように ; を終端に入れていないとエラーになります。

// @lnsFront: error
print( "Hello world." )

このとき、以下のエラーメッセージが出力されます。

mini.lns:1:23: error: EOF
lua5.3: ./lune/base/Util.lua:176: has error
stack traceback:
	[C]: in function 'error'
	./lune/base/Util.lua:176: in function 'lune.base.Util.err'
	./lune/base/TransUnit.lua:3465: in method 'error'
	./lune/base/TransUnit.lua:3538: in method 'getToken'
	./lune/base/TransUnit.lua:11641: in method 'analyzeStatement'
	./lune/base/TransUnit.lua:3710: in method 'analyzeStatementList'
	./lune/base/TransUnit.lua:5430: in function <./lune/base/TransUnit.lua:5393>
	(...tail calls...)
	./lune/base/front.lua:848: in method 'loadFileToLuaCode'
	./lune/base/front.lua:914: in method 'loadFile'
	./lune/base/front.lua:1066: in method 'loadModule'
	./lune/base/front.lua:1709: in method 'exec'
	./lune/base/front.lua:1744: in function 'lune.base.front.exec'
	lune/base/base.lua:1: in main chunk
	[C]: in ?

このエラー出力において、次のメッセージがコンパイルエラーを示します。

mini.lns:1:23: error: EOF

このエラーは、 mini.lns の 1 行目の 23 バイト目で、 予期しない EOF エラーが発生したことを示しています。

これ以外のエラー出力は、 LuneScript 内部のエラーです。 LuneScript 内部のエラー出力を抑制するには、 次のオプション (diag –nodebug) を指定します。

$ lnsc hello.lns exe diag --nodebug
mini.lns:1:23: error: EOF
has error

現在のバージョンでは、デフォルトで内部エラー出力を抑制しています。

内部エラー出力を有効にする場合は –debug オプションを指定します。

ちょっと Hello world をネタにしている記事にしては重い内容ですが、 出力した Lua のコードを見たついでにランタイムについて説明します。

LuneScript から Lua に出力したコードには、 そのコードを動作させるために必要なランタイムが付加されます。

例えば、次の LuneScript のコードを Lua に変換すると、

// @lnsFront: ok
fn add( val:int! ):int {
   return 10 + unwrap val default 0;
}
print( add( 1 ) ); // 11
print( add( nil ) ); // 10

次のようになります。

--mini.lns
local _moduleObj = {}
local __mod__ = 'mini'
local _lune = {}
if _lune1 then
   _lune = _lune1
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

if not _lune1 then
   _lune1 = _lune
end
local function add( val )

   return 10 + _lune.unwrapDefault( val, 0)
end

print( add( 1 ) )
print( add( nil ) )
return _moduleObj

そこそこの量のランタイムが出力されていることが分かると思います。 ちなみに、 local function add( val ) より上が、ランタイムです。

変換元の LuneScript のコードの内容によって挿入されるランタイムが増減します。 ランタイム全てを出力すると、サイズは約 10KB となっています。

このランタイムは、変換した全ての Lua コードに出力されます。

Lua コードにランタイムのコードが挿入されることが気になる場合、 lnsc のコマンドラインオプションに -r を指定することで、 次のようにランタイムの展開を require に置き換えることが出来ます。

--mini.lns
local _moduleObj = {}
local __mod__ = 'mini'
local _lune = require( "lune.base._lune1" )
if not _lune1 then
   _lune1 = _lune
end
local function add( val )

   return 10 + _lune.unwrapDefault( val, 0)
end

print( add( 1 ) )
print( add( nil ) )
return _moduleObj

ただしこの場合、 lune.base._lune1 を require することになるので、 lune.base._lune1 がロードできるようにロードパスを通しておく必要があります。

ここで、 _lune1 の 1 はランタイムのバージョンを示します。

Lua 版の LuneScript が動作している環境であれば気にする必要はないですが、 変換した Lua コードだけを別の環境で動かす場合は注意が必要です。

なお、 -r オプションの代わりに --runtime mod オプションを指定することで、

--mini.lns
local _moduleObj = {}
local __mod__ = 'mini'
local _lune = require( "mod" )
if not _lune1 then
   _lune1 = _lune
end
local function add( val )

   return 10 + _lune.unwrapDefault( val, 0)
end

print( add( 1 ) )
print( add( nil ) )
return _moduleObj

上記のように lune.base._lune をロードする代わりに、 指定の mod モジュールに切り替えることが出来ます。

LuneScript のバージョンが変わると、LuneScript のランタイムも変わることがあります。 もしも、異なるバージョンの LuneScript で変換した Lua モジュールが混在する場合、 デフォルトの lune.base._lune を使用すると正常に動作しないことがあります。

これを避けるために、 –runtime オプションを利用して、 意図しないバージョンのランタイムがロードされることを防止します。

なお、コマンドラインに -mklunemod path を指定することで、 指定の path にランタイムのモジュールファイルを生成します。

LuneScript におけるコメントは、 // と /* */ です。

// は行末までをコメントとし、 /* */ は複数行をコメントとして扱います。

次回は LuneScript で扱う値について説明します。

ここでいう「クロスコンパイル」とは、 Lua のバージョン間の「クロスコンパイル」という意味です。

LuneScript は、Lua へのトランスコンパイルを行なう際、 LuneScript を実行している Lua のバージョンに合せたトランスコンパイルを行ないます。

例えば、次のような制御を行ないます。

• Lua5.2 で実行している場合、ビット演算は bit32 ライブラリを利用する。
• Lua5.3 で実行している場合、ビット演算は Lua の組込み演算子を利用する。

クロスコンパイルは、出力する Lua のコードを、 LuneScript を実行している Lua のバージョンではなく、 指定の Lua バージョンにトランスコンパイルします。

これにより、次のようなことが可能になります。

「LuneScript は Lua5.3 で実行し、トランスコンパイル先は Lua5.1 にする」

$ lnsc src.lns lua -ol 51

これまで LuneScript は、実行に Lua5.2, Lua5.3 が必要でしたが、 上記クロスコンパイル対応によって、 Lua5.1 でも実行できるようになりました。

LuneScript は、それ自体を LuneScript で開発するセルフホスティングであるため、 LuneScript 自体をクロスコンパイルすることで Lua5.1 対応しました。

LuneScript で開発することにより、「生産性を上げる」ということ以外にも、 「Lua のバージョン違いを ある程度 吸収できる」というメリットがあります。

ただし、吸収できるのはあくまでも ある程度 です。

Lua5.1 は、次節で説明する制限があります。

// @lnsFront: ok
print( string.format( "%d,%s,%s,%s",  1, 1.0, {}, [] ) );

print( string.format( "%d,%s,%s,%s", 1, tostring( 1.0), tostring( {}), tostring( {}) ) )

// @lnsFront: ok
let formatTxt = "%d,%s,%s,%s";
print( string.format( formatTxt,  1, 1.0, {}, [] ) );

LuneScript は、 Lua のバージョン間のクロスコンパイルをサポートします。

これにより Lua5.1, Lua5.2, Lua5.3 での、実行をサポートします。

ただし、 Lua5.1 には制限があります。

次回はクラスについて説明します。

LuneScript で扱える値の型と、トランスコンパイラ後の Lua の値との対応表を示します。

2019/3 Set 追加。 2020/10 Luaval 追加 2023/1 タプル追加

上記の通り、 LuneScript では Lua の値を細分化してそれぞれを個別の型として扱います。

細分化の意図は、 Lua の次の仕様を改善することです。

• Lua の数値は全て実数であり、 慣れていないと数値が実数であることによる不具合が生じる。 例えば 10/3 の Lua の計算結果は、3 ではなく 3.3333 となる。

• Lua のテーブルは、全てのキーが自然数となる シーケンス と、 キーが自然数とならない 非シーケンス に分かれる。

  • この違いによって、テーブル内のデータを列挙する際の関数が ipairs と pairs に分かれており、使い分けが必要になる。

    • pairs だけを使っていれば問題ないとも言えるが。。。
  • テーブルのサイズを取得する # 演算子は、シーケンスのサイズを返すものであり、 非シーケンスのサイズを返さないため、紛らわしい。

// @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 );

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

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

// @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

// @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

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

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

// @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

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

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

// @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 )

// @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 };

// @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
}

Set は値の集合を管理し、 Map は値と値の紐付けを管理します。

どちらも Lua に変換した場合、テーブルとして管理するため、 Map よりも Set を使った方が実行速度やメモリ面で優位ということはありません。

しかし、Map ではなく Set を使うことで、次の効果があります。

• データの用途が明確になる
• 無駄に Map の value を扱う必要がない
• リテラルな値が書き易い

次の点において Set と Map は同じです。

• 格納する値の順序を保持しません。
• nilable は格納できません。

Set は次のように書くことでデータを生成します。

// @lnsFront: ok
let obj = (@ 1, 2, 3, 4 ); // 1 2 3 4

これは、1,2,3,4 のデータを保持する Set です。

Set は (@ ) で値を括ります。

なお、上記処理は型推論により型宣言を省略していますが、 省略しない場合は次のように書きます。

// @lnsFront: ok
let obj:Set<int> = (@ 1, 2, 3, 4 ); // 1 2 3 4

Set<int> は、要素が int である Set を宣言します。

空の Set を使用する場合は、型推論できないため型を明示する必要があります。

// @lnsFront: ok
let obj:Set<int> = (@);

次の操作をサポートします。

• 追加

  • add()

• 削除

  • del()

• 有無確認

  • has()

• 要素数取得

  • len()

• 複製

  • clone()

Set への値の追加、削除は次のように行ないます。

// @lnsFront: ok
let mut obj = (@ 1, 2, 3, 4 );
obj.add( 0 );  // 0 1 2 3 4
obj.del( 2 );  // 0 1 3 4

Set で管理する値の有無確認は、次のように行ないます。

// @lnsFront: ok
let obj = (@ 1, 2, 3, 4 );
print( obj.has( 0 ) );  // false
print( obj.has( 1 ) );  // true

Set は、 len() メソッドで要素の数を取得できます。 ただし、 len() メソッドは要素を列挙して数を計算するため、計算量はサイズに比例します。

// @lnsFront: ok
let mut obj = (@ 1, 2, 3, 4 );
print( obj.len() );

同じ Set を生成するには clone() を使用します。

// @lnsFront: ok
let obj = (@ 1, 2, 3, 4 );
let obj2 = obj.clone();

clone は、要素を shallow コピーします。

次の操作をサポートします。

• 合成

  • or()
  • 二つの集合の和を残す

• 共通

  • and()
  • 二つの集合の共通部分を残す

• 差分

  • sub()
  • 現在の集合から引数の集合と共通しない部分を残す

なお、この操作は対象の Set の内容を書き変えます。

// @lnsFront: ok
let set1 = (@  1, 2, 3 );
let set2 = (@  2, 3, 4 );
let set3 = set1.clone().or(set2);   // 1 2 3 4
let set4 = set1.clone().and(set2);  // 2 3 
let set5 = set1.clone().sub(set2);  // 1

タプルは次のように書くことでオブジェクトを生成します。

// @lnsFront: ok
let obj = (= 1, "abc" ); // 1 "abc"

これは、1, "abc" の値の組み合わせを保持するタプルです。

タプルは (= ) で値を括ります。

必ず 1 つ以上のデータを指定する必要があります

上記処理は型推論により型宣言を省略していますが、 省略しない場合は次のように書きます。

// @lnsFront: ok
let obj:(int,str) = (= 1, "abc" ); // 1 "abc"

(int,str) は、要素が int と str であるタプルの型を宣言します。

// @lnsFront: skip
fn func(): (id:int, mess:str);

// @lnsFront: skip
fn func(): (int,str);

タプル型に格納されている値を展開するには ... 演算子を使用します。

  // @lnsFront: ok
  fn func(): (int,str) {
     return (= 1, "abc" );
  }

  let val1,val2 = func()...; // 1 "abc"
  print( val1 + 10, val2 .. "xyz" ); // 11 abcxyz

タプル型の値の後に ... を指定することで、タプルが展開されます。

なお、次のような方法でタプルの各要素を参照することはできません。

// @lnsFront: error
let val = (= 1, "abc" ); // 1 "abc"
print( val[1] ); // error

以上。

LuneScript の enum は、値の集合に名前を付けて管理することが出来ます。

enum として扱える値の型は次の通りです。

• int
• real
• str

1 つの enum の値域は、複数の値から定義できますが、 値の型は統一する必要があります。

つまり、 int の値を持つ enum は、 real や str の値は定義できません。

// @lnsFront: ok
enum TestEnum {
  val0,
  val1,
  val2,
}
print( TestEnum.val0, TestEnum.val1, TestEnum.val2 );  // 0, 1, 2

// @lnsFront: ok
enum TestEnum {
  val0 = 10,
  val1,
  val2 = 20,
}
print( TestEnum.val0, TestEnum.val1, TestEnum.val2 ); // 10, 11, 20

// @lnsFront: ok
enum TestEnum {
  val0 = "abc",
  val1 = "def",
  val2 = "ghi",
}
print( TestEnum.val0, TestEnum.val1, TestEnum.val2 ); // abc def ghi

// @lnsFront: error
fn func(): int {
  return 100;
}
enum TestEnum {
  val0,
  val1 = val0 + 10,  // 10
  val2 = func(),     // error
}

// @lnsFront: ok
enum TestEnum {
  val0,
  val1,
  val2,
}
fn func( val:TestEnum ): int {
   return val + 100;
}
print( func( TestEnum.val1 ) ); // 101

// @lnsFront: ok
enum TestEnum {
  val0,
  val1,
  val2,
}
fn func( val:TestEnum ): int {
   return val + 100;
}
print( func( .val1 ) ); // 101

// @lnsFront: error
enum TestEnum {
  val0,
  val1,
  val2,
}
fn func( val:TestEnum ): int {
   return val + 100;
}
let val = 1;
func( val ); // error

// @lnsFront: ok
enum TestEnum {
  val0,
  val1,
  val2,
}
fn func( val:TestEnum ): int {
   return val + 100;
}
let val = 1;
func( unwrap TestEnum._from( val ) );

// @lnsFront: ok
enum TestEnum {
  val0,
  val1,
  val2,
}
fn func( val:TestEnum ) {
   print( val.$_txt ); 
}
func( .val1 ); // TestEnum.val1

// @lnsFront: ok
enum TestEnum {
  val0,
  val1 = 10,
  val2 = 10,
}
fn func( val:TestEnum ) {
   print( val.$_txt ); 
}
func( .val1 ); // TestEnum.???

// @lnsFront: ok
enum TestEnum {
  val0,
  val1,
  val2,
}
foreach val in TestEnum.$_allList {
   print( val.$_txt );
}

TestEnum.val0
TestEnum.val1
TestEnum.val2

enum 型は、 int, real, str のいずれか一種類の型をグルーピングして、 値域を制限できますが、複数の型をグルーピングすることは出来ません。 代数的データ型は enum 型をより一般的にしたもので、 int, real, str に限らず全ての型をグルーピングすることが出来ます。

詳しくは次の記事で説明しています。

#match

enum を利用することで、値域を簡単に定義することが出来、 enum を楽に扱うイマドキな手段を提供しています。

次回は、変数について説明します。

enum 型は、 int, real, str のいずれかの値をグルーピングして、値域を制限できます。

一方、代数的データ型は enum 型をより一般的にしたもので、 int, real, str に限らず全ての型をグルーピングすることが出来ます。

代数的データ型は alge キーワードで宣言します。

次に例を示します。

// @lnsFront: ok
class Hoge {
   pri let val:int {pub};
}
alge Test {
   Val1,
   Val2( int ),
   Val3( str ),
   Val4( Hoge ),
   Val5( num:int, txt:str ),
}

この例では、 alge 型 Test を宣言しています。

Test は、 Val1 〜 Val5 までの値域を持ちます。 また、 Val1 〜 Val5 はそれぞれ次のパラメータを持ちます。

パラメータの型に制限はありません。 この例の場合、 Val4 は Hoge クラス型をパラメータに持ちます。

パラメータの個数も制限はありません。 この例の場合、 Val5 は int と str をパラメータに持ちます。

パラメータには、型だけ指定する方法と、名前と型を指定する方法があります。 この例の場合、 Val2 から Val4 は型だけ指定し、 Val5 はパラメータ名と型を指定しています。 パラメータ名は、そのパラメータの意味を明瞭にする効果があるだけです。

この alge 型の値を使用する場合、次のように書きます。

// @lnsFront: skip
let val1 = Test.Val1;
let val2 = Test.Val2( 1 );
let val3 = Test.Val3( "abc" );
let val4 = Test.Val4( new Hoge( 100 ) );
let val5 = Test.Val5( 10, "xyz" );

それぞれの意味は次になります。

• val1 は Test.Val1
• val2 は 1 をパラメータに持つ Test.Val2
• val3 は "abc" をパラメータに持つ Test.Val3
• val4 は new Hoge( 100 ) をパラメータに持つ Test.Val4
• val5 は 10, "xyz" をパラメータに持つ Test.Val5

enum 型は、次のように元の値と同じように使用できます。

// @lnsFront: ok
enum TestEnum {
  val0,
  val1,
  val2,
}
fn func( val:TestEnum ): int {
   return val + 100;
}
let val = 1;
func( unwrap TestEnum._from( val ) );

この例では、 関数 func() 内で TestEnum 型の値 + 100 をしていますが、 これは TestEnum 型が int の数値としても利用できることを示しています。

一方で alge 型の値は、特別な処理が必要です。 その処理が match です。

次に match の例を示します。

// @lnsFront: ok
class Hoge {
   pri let val:int {pub};
}

alge Test {
   Val1,
   Val2( int ),
   Val3( str ),
   Val4( Hoge ),
   Val5( int, str ),
}

fn func( test:Test ) {
   match test {
      case .Val1 {
         print( test.$_txt );
      }
      case .Val2( x ) {
         print( test.$_txt, x );
      }
      case .Val3( x ) {
         print( test.$_txt, x );
      }
      case .Val4( x ) {
         print( test.$_txt, x.$val );
      }
      case .Val5( x, y ) {
         print( test.$_txt, x, y );
      }
   }
}

func( Test.Val1 ); // Test.Val1
func( Test.Val2( 1 ) ); // Test.Val2 1
func( Test.Val3( "abc" ) ); // Test.Val3 abc
func( Test.Val4( new Hoge( 100 ) ) ); // Test.Val4  100
func( Test.Val5( 10, "xyz" ) ); // Test.Val5 10 xyz

この例では、 func() 関数内で match を実行しています。

case によって Val1 〜 Val5 を分岐しています。 また Val2 〜 Val5 は、それぞれパラメータを受け取る変数を宣言しています。

例えば func( Test.Val2( 1 ) ) は、 Test.Val2( 1 ) を func() に渡しています。 ここで func() 内の match の case .Val2( x ) にマッチします。 そして、 x には 1 がセットされ、 print( test.$_txt, x ) が実行されます。

ここで test.$_txt は、 値域の Val2 を示す "Test.Val2" の文字列が展開されます。

match は、 switch と同様に default と _default、そして _match を利用できます。

alge 型も enum 型と同じように省略表記を利用できます。

次のような alge 型の Test と、その Test を引数に持つ関数があった場合、

// @lnsFront: ok
alge Test {
   Val1,
   Val2,
   Val3( int ),
}
fn func( test:Test ) {
   print( test );
}

func() をコールする際、次のように Test を省略可能です。

// @lnsFront: skip
func( .Val1 );
func( .Val2 );
func( .Val3( 10 ) );

なお、 外部モジュールで定義されている alge 型を省略指定する場合、 その外部モジュールを import している必要があります。

パラメータを持たない単純な alge 型の値は、次のように比較することが出来ます。

// @lnsFront: error
alge Test {
   Val1,
   Val2,
   Val3( int ),
}
fn func( test:Test ) {
   if test == .Val1 {
      print( "Val1" );
   }
   elseif test == .Val2 {
      print( "Val2" );
   }
   elseif test == .Val3(1) {  // error
      print( "Val3" );
   }
   else {
      print( "no" );
   }
}
func( .Val1 ); // Val1
func( .Val2 ); // Val2

なお、パラメータを持つ値 (上記の場合 Val3) は、 同じパラメータを与えても異なる値になるため注意が必要です。 ちなみに、上記の test == .Val3(1) はエラーとなります。 なぜならば、この式の結果は必ず「false」となるため、 コンパイルエラーとすることで、実行時に意図しない結果になることを防ぎます。

alge を使うと JSON 構造を次のように書くことが出来ます。

// @lnsFront: ok
alge JsonVal {
   JNull,
   JBool(bool),
   JInt(int),
   JReal(real),
   JStr(str),
   JArray(List<JsonVal>),
   JObj(Map<str,JsonVal>),
}
fn dumpJson( stream:oStream, jval:JsonVal ) {
   match jval {
      case .JNull {
         stream.write( "null" );
      }
      case .JBool( val ) {
         stream.write( "%s" (val) );
      }     
      case .JInt( val ) {
         stream.write( "%d" (val ) );
      }        
      case .JReal( val ) {
         stream.write( "%g" (val ) );
      }        
      case .JStr( val ) {
         stream.write( '"%s"' (val ) );
      }        
      case .JArray( list ) {
         stream.write( "[" );
         foreach val, index in list {
            if index > 1 {
               stream.write( "," );
            }
            dumpJson( stream, val );
         }
         stream.write( "]" );
      }        
      case .JObj( map ) {
         stream.write( "{" );
         let mut cont = false;
         foreach val, key in map {
            if cont {
               stream.write( ',' );
            }
            else {
               cont = true;
            }
            stream.write( '"%s":' (key) );
            dumpJson( stream, val );
         }
         stream.write( "}" );
      }
   }
}
dumpJson( io.stdout,
          JsonVal.JObj( { "foo": JsonVal.JInt( 1 ),
                          "bar": JsonVal.JStr( "abc" ) } ) );

alge を使用せずにキャストや継承などを利用すれば同じことは出来ます。 しかし、キャストはもちろん、継承にも欠点があります。

alge も万能ではありませんが、 幾つかの場面ではキャストや継承を使用するよりも、 より良い選択肢になると思います。

次回はインタフェースを説明します。

LuneScript は静的型付け言語であり、変数は型を持ちます。

変数は、次のように let で宣言します。

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

上記の例は、初期値として int の 1 を持つ変数 val を宣言しています。

変数名の後には、型を指定します。

なお、初期値が int の 1 ではなく、 real の 1.0 をセットすると、型が違うためコンパイルエラーになります。

// @lnsFront: error
let val:int = 1.0;  // error

また、現在は変数宣言には初期値が必須です。

これは、未初期化変数へのアクセスを防ぐためです。 将来的には、変数が値を保持しているかどうかをフロー解析で判断できるようにして、 初期値不要にすることを考えています。

変数宣言時の初期化は必須ではありません。 なお、初期化していない変数を参照した場合、コンパイルエラーになります。 詳しくは後述します。

また、変数宣言時に初期化しない場合でも、型推論は可能です。

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

// @lnsFront: error
{
   let val;
   print( "%s" ( val ) ); // 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 );
}

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

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

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

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

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

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

// @lnsFront: skip
print( val2 );

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

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

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

// @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

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

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

// @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 );
}

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

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

nil 以外の全ての値は、 stem 型の変数に代入できます。

これには、暗黙的な型変換が行なわれています。

// @lnsFront: ok
let mut val:stem = 1;
val = 1.0;
val = "abc";
val = {};
val = [];
val = [@];

一方、 stem 型の値から異なる型への代入はエラーします。

// @lnsFront: error
let val1:stem = 1;
let val2:int = val1; // error

明示的な型変換が必要な場合は、次の記事を参照してください。

#cast

変数は、 一部(int,real,nil)を除いてオブジェクトの参照を保持します。

例えば次の場合、

// @lnsFront: ok
let mut list1 = [ 10 ];
let list2 = list1;
list1.insert( 20 );
list1.insert( 30 );
foreach val in list2 {
   print( val ); // 10 20 30
}

• list1 に List<int> 型のリスト ([ 10 ])オブジェクトの参照をセット
• list2 に list1 が保持する参照をセット
• list1 が参照するリストオブジェクトに 20, 30 を insert
• list2 が参照するリストオブジェクトの各値を print()

ここで、 list1 と list2 は 同じリストオブジェクト を参照しているため、 list1 に 20, 30 を insert すると、 list2 を foreach した print( val ) は 10 20 30 を出力します。

また、次のように list2 に 40 を insert した場合、 同じリストオブジェクト に 40 を挿入するため、 print( val ) は 10 20 30 40 を出力します。

// @lnsFront: ok
let mut list1 = [ 10 ];
let mut list2 = list1;
list1.insert( 20 );
list1.insert( 30 );
list2.insert( 40 );
foreach val in list2 {
   print( val ); // 10 20 30 40
}

list1 に新しいリストオブジェクト ([ 100]) をセットした場合、 list1 が参照するリストオブジェクトと、 list2 が参照するリストオブジェクトは異なるため、 print( val ) は 10 20 30 40 を出力します。

// @lnsFront: ok
let mut list1 = [ 10 ];
let mut list2 = list1;
list1.insert( 20 );
list1.insert( 30 );
list2.insert( 40 );
list1 = [ 100 ];
foreach val in list2 {
   print( val ); // 10 20 30 40
}

これは、 List<List<int>> の場合も同じです。

// @lnsFront: ok
let mut list = [ 10, 20 ];
let mut wrapList:List<List<int>> = [];
wrapList.insert( list );
wrapList.insert( list );
wrapList.insert( [ 100, 200 ] );
list[ 1 ] = list[ 1 ] + 1;
print( wrapList[ 1 ][ 1 ], wrapList[ 1 ][ 2 ] ); // 11 20
print( wrapList[ 2 ][ 1 ], wrapList[ 2 ][ 2 ] ); // 11 20
print( wrapList[ 3 ][ 1 ], wrapList[ 3 ][ 2 ] ); // 100 200

wrapList の 1, 2 番目に list を追加し、 wrapList の 3 番目に新しいリストオブジェクトを追加している。 その後 list[1]をインクリメント後、wrapList の中身を出力する。

ここで、 wrapList[1][1] と wrapList[2][1] は、同じ list[1] を指すため、 インクリメントされた値が出力される。 wrapList[3] は新しいリストオブジェクトになるため、インクリメントの影響はない。

LuneScript の変数には、次の要素を取り入れています。

• 型推論
• アクセス制御
• mutable
• 複数宣言

Lua を静的片付けで扱う際に必要となる、最低限の機能を満しているつもりです。

次回は、 LuneScript の分岐制御について説明します。

LuneScript は、次の一般分岐構文をサポートします。

• if
• switch

ちなみに、ここであえて「一般」分岐制御としているのは、 nilable 制御で別途分岐制御があるためです。

// @lnsFront: ok
let val = 1;
if val == 1 {
   print( "hoge" );
}
elseif val == 2 {
   print( "foo" );
}
else {
   print( "bar" );
}

// @lnsFront: ok
   let val1 = true;
   if val1 == true {
   }
   if val1 == false {
   }
   if val1 ~= false {
   }
   if val1 ~= true {
   }

// @lnsFront: ok
let exp = true;
if exp {
   print( "exp is true" );
}
else {
   print( "exp is false" );
}
if not exp {
   print( "exp is false" );
}

// @lnsFront: ok
let val = 1;
switch val {
   case 1 {
      print( "hoge" );
   }
   case 2 {
      print( "foo" );
   }
   default {
      print( "bar" );
   }
}

// @lnsFront: ok
let val = 1;
switch val {
   case 10, 20, 30 {
      print( "hoge" );
   }
   default {
      print( "bar" );
   }
}

// @lnsFront: ok
let val = 1;
if val == 10 or val == 20 or val == 30 {
   print( "hoge" );
}
else {
   print( "bar" );
}

// @lnsFront: ok
for count = 1, 10 {
   switch count {
      case 5 {
         break;
      }
   }
}

// @lnsFront: error
enum Val {
   Val1,
   Val2,
}
fn func( val:Val ) {
   switch val {
      case .Val1 {
         return;
      }
      case .Val2 {
         return;
      }
   }
   print( work ); // error : 全ての enum 値の case があり、 return している
}

// @lnsFront: ok
enum Val {
   Val1,
   Val2,
}
fn func( val:Val ) {
   switch val {
      case .Val1 {
         return;
      }
      case .Val2 {
         return;
      }
      default { // warning : ここには到達しない
         return;
      }
   }
}

// @lnsFront: ok
enum Val {
   Val1,
   Val2,
}
fn func( val:Val ) {
   switch val {
      case .Val1 {
         return;
      }
      case .Val2 {
         return;
      }
      _default { // ここには到達しないが、 warning は出力されない
         return;
      }
   }
}

// @lnsFront: ok
enum Val {
   Val1,
   Val2,
}
fn func( val:Val ) {
   _switch val {
      case .Val1 {
         return;
      }
      case .Val2 {
         return;
      }
   }
}

// @lnsFront: error
enum Val {
   Val1,
   Val2,
}
fn func( val:Val ) {
   _switch val { // error
      case .Val1 {
         return;
      }
   }
}

LuneScript の一般分岐構文は、 if と switch があります。

goto はありません。

次回は、繰り返し制御について説明します。

LuneScript は、次の繰り返し構文をサポートします。

• while
• repeat (将来削除予定)
• for
• apply
• foreach
• forsort

// @lnsFront: ok
let mut val = 1;
while val < 10 {
   val = val + 1;
}
print( val ); // 10
repeat {
   let mut endFlag = false;
   val = val + 1;
   if val >= 20 {
      endFlag = true;
   }
} endFlag;
print( val ); // 20

// @lnsFront: skip
let flag = true;
while flag {
}

// @lnsFront: error
while true {
}
print( "hoge" );

// @lnsFront: ok
for count = 1, 10, 1 {
  print( count );
}

// @lnsFront: ok
let mut addVal = 1;
for count = 1, 10, addVal {
  addVal = addVal + 1;
  print( count );
}

// @lnsFront: ok
apply txt of string.gmatch( "hoge.foo.bar", '[^%.]+' ) {
   print( txt );
}

// @lnsFront: ok
foreach val, index in [ 1, 2, 3 ] {
   print( index, val );
}
foreach val, index in [@ 10, 20, 30 ] {
   print( index, val );
}
foreach val, key in { "a":100, "b":200, "c":300 } {
   print( key, val );
}
foreach val in (@ 1, 2, 3 ) {
   print( val );
}

// @lnsFront: ok
foreach val in [ 1, 2, 3 ] {
   print( val );
}
foreach val in [@ 10, 20, 30 ] {
   print( val );
}
foreach val in { "a":100, "b":200, "c":300 } {
   print( val );
}

// @lnsFront: skip
let mut list = [ 1, 2, 3 ];
foreach val, index in list {
   list[ index ] = val + 10;
}

// @lnsFront: ok
forsort val, key in { "b":200, "c":300, "a":100 } {
   print( key, val );
}
forsort val in (@ 2, 4, 1, 0 ) {
   print( val );
}

// @lnsFront: ok
forsort val in { "b":200, "c":300, "a":100 } {
   print( val );
}

LuneScript の一般制御構文は、基本的に Lua と同じです。

主な違いは、リスト等を処理する foreach, forsort を追加していることです。

次回は関数を説明します。

LuneScript の関数は次のように定義します。

// @lnsFront: ok
fn add_sub( val1:int, val2:int ): int, int {
   return val1 + val2, val1 - val2;
}
print( add_sub( 1, 2 ) ); // 3, -1

上記の例は、次の関数を定義しています。

LuneScript は、戻り値を複数返せます。

関数によっては、処理を戻さないものがあります。

次に例を示します。

// @lnsFront: error
fn func(): __ {
   while true {
   }
}
func();
print( 1 ); // error

この例では、 func() は無限ループです。 よって、 func() は処理を返さないことになります。

これを明示するため、 func() の戻り値の型は __ となっています。 __ は、処理を戻さない関数であることを示します。

これによって、 func() の次の print() 文が処理されないことが分かり、 エラーとなります。

なお、 戻り値型を __ とした関数は、 処理を戻さないようにしなければなりません。

例えば次のように break すると、ループを抜けてしまうため、 func() から処理が戻ってきます。 このような場合は、エラーとなります。

// @lnsFront: error
fn func(val:int): __ {
   while true {
      if val == 1 {
         break;
      }
   }
}

可変長引数、戻り値を利用できます。

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

#arg

関数は、 statement が書ける場所であればどこでも定義可能です。 具体的には次のようにブロック内に定義できます。

// @lnsFront: ok
fn sub():int {
   let mut val = 0;
   {
      {
         fn func(): int {
            return 1;
         }
         val = val + func();
      }
      fn func(): int {
         return 2;
      }
      val = val + func();
   }
   fn func(): int {
      return 3;
   }
   return val + func();
}
print( sub() ); // 6

スコープが異なれば、同名関数を定義できます。

関数も変数と同様、pub を使って外部公開できます。

// @lnsFront: ok
pub fn func(): int {
   return 1;
}

pub を指定することで、外部からアクセス可能な関数となります。

global も利用できます。

// @lnsFront: ok
global fn func(): int {
   return 1;
}

関数の global 宣言には、 変数の global 宣言と同じ制約があります。

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

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

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

LuneScript は、関数オブジェクトを値として扱うことが出来ます。 特殊な関数オブジェクトの型として form を利用できます。

次に form の使用例を示します。

// @lnsFront: ok
fn test() {
   print( "hoge" );
}
fn sub( func:form ) {
  func();
}
sub( test ); // hoge

この例は、次の構成となります。

• 関数 test を定義
• 関数 sub は form 型の引数を持つ
• 引数として test を指定して sub を実行

これによって、 sub 内で test が実行され、 hoge が出力されます。

なお、 form 型は次の関数として扱います。

// @lnsFront: skip
fn func(...):... {}

// @lnsFront: error
fn func( val:int ) {
   print( val + 1 );
}
let func2:form = func;
func2( nil );

// @lnsFront: error
let form1:form = fn ( val1:stem! ) { };
let form2:form = fn ( val1:stem ) { };  // error
let form3:form = fn ( val1:stem!, val2:stem! ) { };
let form4:form = fn ( val1:stem!, val2:stem ) { }; // error

// @lnsFront: ok
form funcform( val:int ):int;
fn sub( func:funcform ) {
   print( func( 1 ) + 1 );
}
sub( fn ( val:int ):int { return val + 1; } ); // 3

anonymous 関数は、名前を持たない関数を定義します。

次は anonymous 関数の例です。

// @lnsFront: ok
fn sub( func:form ) {
  func( 1 );
}
sub( fn ( val:stem! ) { print( val ); } );  // 1

この例では、 anonymous 関数 fn ( val:int ) { print( val ); } を定義しています。

この anonymous 関数を sub() の引数に渡すことで、 sub() 内で anonymous 関数が実行されます。

anonymous 関数宣言は式です。

関数オブジェクトに () を付けることで、その関数が実行されます。

関数の仮引数と実引数の型は一致しなければなりません。 なお、省略した実引数は nil として扱います。 もし省略した実引数に対応する仮引数が nilable でなかった場合、エラーとなります。

LuneScript の関数は、引数の違いによるオーバーロードはできません。

LuneScript の関数をまとめると、

• fn で宣言する
• 複数の戻り値を持てる
• 可変長の引数、戻り値をもてる
• pub, global で外部モジュールに関数を公開する
• 関数オブジェクトの型は、form 型と form 宣言を使用する
• anonymous 関数がある
• 省略した実引数には nil が入る
• 関数オーバーロードはない

次回は nilable について説明します。

次のコードは LuneScript ではなく、 Lua のコードです。

local function func1( txt ) 
   print( string.byte( txt:gsub( "b", "B" ) ) )
end
local function func2( txt ) 
   print( string.byte( (txt:gsub( "b", "B" )) ) )
end
func1( "abcb" ) -- 66
func2( "abcb" ) -- 97

この func1() と func2() は、同じ引数 "abcb" を与えているのに異なる結果を出力します。 何故そうなるか分かるでしょうか？

ちなみに txt:gsub( "b", "B" ) は、 文字列 txt 内の "b" を "B" に変換した文字列を返す Lua の標準ライブラリで、 string.byte() は、 指定の文字列に含まれる値を返す標準ライブラリです。

それでは問の答です。

func1() は string.byte に txt:gsub( "b", "B" ) の 戻り値そのままを渡しているのに対し、 func2() は () で括った (txt:gsub( "b", "B" )) を渡しています。

これにより、 func1() は string.byte() に txt:gsub( "b", "B" ) の多値の値をそのまま渡しているのに対し、 func2() は string.byte() に txt:gsub( "b", "B" ) の多値の先頭の値である文字列だけを渡しています。

string.byte() は、 第2引数が渡された場合、 第2引数が指定するインデックスの文字の値を返します。 一方、第2引数が省略された場合、先頭の文字の値を返します。

そして、 txt:gsub( "b", "B" ) は多値を返す関数です。 具体的には、変換後の文字列 str と何箇所変換したか int を返します。

txt:gsub( "b", "B" ) が変換した文字列を返す関数であることは、 Lua を利用している人であれば認識していることだと思います。 一方で、この関数が多値を返す関数だと認識している人はどの程度いるでしょうか？

また、認識していたとして、それが不具合につながるということに即座に気付く人は どれほどいるでしょうか？

本来 txt:gsub( "b", "B" ) の変換後の文字列だけを引数として使用したいのに、 意図せずに渡された多値の戻り値によって、関数動作が変ってしまうことがあります。

つまり、本来は func2() のように () を使って多値の先頭だけ使わなければならない時に、 func1() のようにそのまま多値を使ってしまうことがあるのです。

ここで冒頭で書いたことを思い出してください。

• 多値の戻り値は非常に便利ですが、戻り値が多値である言語はまだまだ少ないです。
• また、戻り値の 2 番目以降の値は、オプション的な意味合いのケースが多いです。
• そのため、2 番目以降の戻り値の存在を忘れがちです。

多値の戻り値は便利ですが、このようなリスクもあるんです。

LuneScript では、このように問題を避けるため多値の戻り値を扱う際、 明示することにしました。 なお、明示しない場合は warning となります。

ただ、多値を利用する際に明示するのは、それはそれで面倒です。

そこで、明示が必要なケースとして、次のケースに限定します。

多値の戻り値の利用先が

• 関数の引数で、なおかつその引数が省略可能な場合
• return に指定する値で、なおかつその値が省略可能な場合

つまり、 let など直接変数に値を代入するような場合は、明示は不要です。 わざわざ値を代入する変数を用意しているということ自体が、 多値の第二引数以降を使用すると明示しているのと同様だと考えたためです。

具体的な明示方法は次になります。

// @lnsFront: ok
fn func1(): int,int {
   return 1, 2;
}
fn func2( val1:int, val2:int!) {
   print( val1, val2 );
}

func2( func1()** );

上記 func1()** のように、関数コールの後に ** を付加することで、 その関数コールの多値を使用していることを明示します。

上記で示す通り、多値を返す関数の実行結果をそのまま別の関数の引数に渡すことができます。

但し、多値を返す関数の戻り値をそのまま多値として扱うには、 関数の後に何も指定していない場合に限ります。

これはどういうことかというと、 以下のように多値の戻り値を返す関数 func1 の実行結果を print で出力する際、 func1 の後に指定していると、 func1 の実行結果は先頭の値だけが処理されます。

// @lnsFront: ok
fn func1(): int,int {
   return 1, 2;
}
print( func1() );      // 1 2
print( func1(), 10 );  // 1 10
print( 0, func1() );  // 0 1 2

上の例の場合、

• print( func1() ) は、多値の戻り値 1 2 がそのまま処理される。
• print( func1(), 10 ) は、多値の戻り値の先頭の 10 が処理される。
• print( 0, func1() ) は、多値の戻り値 1 2 がそのまま処理される。

これは、 List のコンストラクタなどの場合も同様です。

// @lnsFront: ok
fn func1(): int,int {
   return 1, 2;
}
let list1 = [ func1() ]; // [1 2]
let list2 = [ func1(), 10 ];  // [ 1 10]
let list3 = [ 0, func1() ];  // [0 1 2]

なお、次のように多値の関数呼び出しに () を付けた場合も、多値の戻り値の先頭だけを処理します。

print( (func1()) );

これは、 LuneScript の仕様というよりは、 Lua の仕様にもとづく動作です。

LuneScript では、引数を省略する場合 ## を使用します。

上の func() をコールする場合、次のようになります。

// @lnsFront: skip
print( func(1,2) );  // 3
print( func(1##) );  // 1
print( func(##) );   // 0

引数を省略している箇所に ## を付加することで、 そこは引数を省略していることを明示します。

なお ## を指定せずに省略している場合、 warning となります。

これにより、引数の省略と、引数の指定し忘れを防止しています。

トランスコンパイル時に -Werror オプションを追加することで、 warning を error として扱います。

また、逆に ## の指定が面倒な場合、 –disable-checking-define-abbr オプションを追加することで ## を指定せずに省略している場合の warning を抑制できます。

引数、 戻り値に … を利用することで、 可変長引数、可変長戻り値の関数を定義できます。

… を利用したサンプルを次に示します。

// @lnsFront: ok
fn func( ... ) : int, ... {
   let argList = [ ... ];
   let mut total = 0;
   foreach arg in argList {
      when! arg {
         total = total + arg@@int;
      }
   }
   return total, ...;
}

print( func( 1, 2, 3, 4 ) ); // 10 1 2 3 4

上記の例では、与えられた可変長引数の値を合計し、 合計値と与えられた可変長引数を返す関数 func() を定義、実行しています。

関数本体で … を使用することで、可変長引数そのものを示します。 ここで … は、 0 個以上の stem! の値となります。 stem! については後述します。

可変長引数をもつ関数をコールする側は、 0 個以上のあらゆる型の引数を指定できます。

上記の通り … を利用することで、可変長引数、戻り値を宣言できます。

しかし、 … の値は全て stem! として扱うため型情報が失なわれてしまいます。

上のサンプルでも、 func() には int のデータを渡しているのに、 型情報が失なわれるため func() 内で値にアクセスするには unwrap やキャストが必要になっています。

型情報を保つには、次のように ...<type> を使用します。

// @lnsFront: ok
fn func( ...<int> ) : int, ...<int> {
   let argList = [ ... ];
   let mut total = 0;
   foreach arg in argList {
      total = total + arg;
   }
   return total, ...;
}
print( func( 1, 2, 3, 4 ) ); // 10 1 2 3 4

...<int> を使用することで、 int の型情報を保持したまま可変長引数、戻り値を扱うことが出来ます。

なお、次のサンプルの func1() と func2() は同義です。

// @lnsFront: ok
fn func1( ...<stem!> ) {
   print( ... );
}
fn func2( ... ) {
   print( ... );
}
func1( 1, "abc" );
func2( 1, "abc" );

現状の LuneScript は、大域脱出をサポートしていません。

何等かのエラーが発生した場合、関数の戻り値でエラーを通知する必要があります。

エラーの通知方法としては、大きく次の 2 つがあります。

• nilable を利用し、エラーを nil で表現する。
• alge 型 __Ret を利用する。

// @lnsFront: ok
fn func(flag:bool): str! {
   if not flag {
       return nil;
   }
   return "hoge";
}

// @lnsFront: ok
fn func(flag:bool): str!, str! {
   if not flag {
       return nil, "error";
   }
   return "hoge", nil;
}

// @lnsFront: skip
alge __Ret<T1,T2> {
  Ok(val:T1),
  Err(val:T2),
}

// @lnsFront: ok
fn func(flag:bool): __Ret<str,str> {
   if not flag {
       return .Err("error");
   }
   return .Ok( "hoge" );
}

// @lnsFront: ok
class Hoge {
   fn sub( val:int ) : int! {
      if val > 3 {
	 return nil;
      }
      return val;
   }
   pub fn func( val:int ) : str! {
      let! work1 = self.sub( val + 1 ) {  // check error
         return nil;
      };
      let! work2 = self.sub( val + 2 ) { // check error
         return nil;
      };
      let! work3 = self.sub( val + 3 ) { // check error
         return nil;
      };
      return "%s" (work1 + work2 + work3);
   }
}
let hoge = new Hoge();
print( "%s" (hoge.func( 0 )) );
print( "%s" (hoge.func( 1 )) );

// @lnsFront: ok
class Hoge {
   fn sub( val:int ) : int! {
      if val > 3 {
	 return nil;
      }
      return val;
   }
   pub fn func( val:int ) : str! {
      let work1 = self.sub( val + 1 )!;
      let work2 = self.sub( val + 2 )!;
      let work3 = self.sub( val + 3 )!;
      return "%s" (work1 + work2 + work3);
   }
}
let hoge = new Hoge();
print( "%s" (hoge.func( 0 )) );
print( "%s" (hoge.func( 1 )) );

// @lnsFront: ok
class Hoge {
   fn sub( val:int ) : int!, str! {
      if val > 3 {
	 return nil, "err";
      }
      return val, nil;
   }
   pub fn func( val:int ) : int!, str! {
      let work1 = self.sub( val + 1 )!;
      let work2 = self.sub( val + 2 )!;
      let work3 = self.sub( val + 3 )!;
      return work1 + work2 + work3, nil;
   }
}
let hoge = new Hoge();
print( "%s,%s" ( hoge.func( 0 )) );
print( "%s,%s" ( hoge.func( 1 )) );

// @lnsFront: ok
class Hoge {
   fn sub( val:int ) : __Ret<int,__Er> {
      if val > 3 {
	 return .Err( __serr( "err" ) );
      }
      return .Ok( val );
   }
   pub fn func( val:int ) : __Ret<str,__Er> {
      let work1 = self.sub( val + 1 )!;
      let work2 = self.sub( val + 2 )!;
      let work3 = self.sub( val + 3 )!;
      return .Ok( "%s" (work1 + work2 + work3) );
   }
}
let hoge = new Hoge();
for count = 0, 1 {
   match hoge.func( count ) {
      case .Ok( val ) {
         print( "ok", val );
      }
      case .Err( err ) {
         print( "ng", err.$txt );
      }
   }
}

// @lnsFront: skip
pub interface __Er {
   fn get_txt():str;
}

// @lnsFront: skip
pub fn __err(mess:str): __Er;

// @lnsFront: ok
fn sub(flag:bool) : (int,str)!,str! {
   if flag {
      return (= 1,"abc"), nil;
   }
   return nil, "err";
}

fn func(flag:bool) : (int,str)!,str! {
   let val1, val2 = sub(flag)!...;
   let val3, val4 = sub(flag)!...;
   print( val1, val2, val3, val4 );
   return (= val1 + val3, val2 .. val4 ), nil;
}

foreach cond in [true,false] {
   let tuple, err = func( cond );
   when! tuple {
      let val1,val2 = tuple...;
      print( "ok", val1, val2 );
   } else {
      print( "ng", err );
   }
}

// @lnsFront: ok
fn sub(flag:bool) : __Ret<(int,str),__Er> {
   if flag {
      return .Ok( (= 1,"abc") );
   }
   return .Err( __serr( "err" ));
}

fn func(flag:bool) : __Ret<int,__Er> {
   let val1, val2 = sub(flag)!...;
   let val3, val4 = sub(flag)!...;
   print( val1, val2, val3, val4 );
   return .Ok( val1 + val3 );
}

foreach cond in [true,false] {
   match func( cond ) {
      case .Ok( val ) {
         print( "ok", val );
      }
      case .Err( val ) {
         print( "ng", val.$txt );
      }
   }
}

LuneScript は、値に nil を持ちます。

以前説明しましたが、 stem 型の変数は nil 以外の全ての型を保持できます。

// @lnsFront: error
let mut val:stem = 1;
val = 1.0;
val = "abc";
val = {};
val = [];
val = [@];
val = nil; // error

では、どうすれば nil を保持できるのかというと、 stem ではなく stem! を使用します。

// @lnsFront: ok
let mut val:stem! = 1;
val = 1.0;
val = "abc";
val = {};
val = [];
val = [@];
val = nil; // ok

このように、 nil を保持可能な型を nilable と言います。

nilable は stem! だけでなく、 一部を除く全ての型に nilable 型が存在します。

例えば int! や str! は、 int の nilable 型、 str の nilable 型となります。

型名の末尾に ! を付加することで、 本来の型と nil を保持可能な nilable 型となります。

// @lnsFront: error
let mut val1:int = 1;
val1 = nil;  // error

let mut val2:int! = 1;
val2 = nil;  // ok

nil は、他のどの値とも異なる値で、異常値として利用するのに便利な値です。 しかし、 意図しないタイミングで変数の値が nil になることで、 不具合の原因となることが多くあります。

LuneScript は、 nil を保持出来る nilable 型と、 nil を保持できない非 nilable 型に分けることで、 nil 安全(NULL 安全)を実現しています。

nilable 型は、そのままでは元の型として使用できないという制限があります。

この説明だと何のことだか伝わり難いと思いますので、次の例を見てください。

// @lnsFront: error
let val:int! = 1;
print( val + 1 );  // error

上記の val は int の nilable 型です。 そして val + 1 を実行していますが、これはエラーとなります。

なぜならば、 val は int ではなく int! なので、そのままでは int としては扱えないためです。

では、なぜ nilable にこのような制限があるかというと、次の通りです。

• nilable は nil を保持できる型
• つまり、nilable 型は nil である可能性がある
• 元の型として利用するには、 nil でないことを確認しなければならない

非 nilable の型には nil を代入出来ません。 そして、 nilable 型はそのままで元の型として利用が出来ません。

この制限によって、 ある変数が意図しないタイミングで nil になり、 不具合となることを論理的に防止することが出来ます。

これが多くの言語で取り入れられている nil 安全(NULL安全)の原理です。

前述している通り、nilable 型は、そのままでは非 nilable として利用できません。

しかし、次のように比較すること出来ます。

// @lnsFront: ok
fn check( val:int! ) {
   if val == 1 {
      print( "ok" );
   }
   else {
      print( "ng" );
   }
}
check( 1 ); // ok
check( 2 ); // ng

上記サンプルでは val は int! で、 val == 1 で int と比較しています。 このように nilable と 非 nilable を比較することは可能です。

次のように、非 nilable 型から nilable 型への変換は、暗黙的に行なわれます。

// @lnsFront: ok
let val:int! = 1;   // int! <-- int

一方で nilable 型から非 nilable 型への変換は、明示的に行なう必要があります。

LuneScript では、nilable 型から非 nilable 型への変換に、次のものを用意しています。

• unwrap
• when!
• if!
• if! let
• let!
• unwrap!

// @lnsFront: ok
let val1:int! = 1;
let val2:int = unwrap val1;

// @lnsFront: ok
let val1:int! = nil;
let val2:int = unwrap val1;   // runtime error

// @lnsFront: ok
let val1:int! = nil;
let val2:int = unwrap val1 default 0;

// @lnsFront: ok
fn func( val:int!, val2:int! ): int {
   when! val, val2 {
      return val + val2;
   }
   else {
      return 0;
   }
}
print( func( 1, 2 ) );      // 3
print( func( nil, 2 ) );    // 0
print( func( 1, nil ) );    // 0
print( func( nil, nil ) );  // 0

// @lnsFront: ok
fn func( val:int! ): int! {
   return val;
}
fn sub( val:int! ): int {
   if! func( val ) {
      return _exp + 10;
   }  
   else {
      return 0;
   }
}
print( sub( 1 ) ); // 11
print( sub( nil ) ); // 0

// @lnsFront: skip
   if! func( val ) {
      if! func( val ) {
         return _exp + 10;
      }  
      else {
         return 0;
      }  
   }

// @lnsFront: ok
fn func( val1:int!, val2:int! ): int!, int! {
   return val1, val2;
}
fn sub( val1:int!, val2:int! ): int {
   if! let work1, work2 = func( val1, val2 ) {
      return work1 + work2;
   }  
   else {
      return 0;
   }
}
print( sub( 1, 2 ) ); // 3
print( sub( nil, 2 ) ); // 0
print( sub( 1, nil ) ); // 0
print( sub( nil, nil ) ); // 0

// @lnsFront: ok
fn func( val1:int!, val2:int! ): int!, int! {
   return val1, val2;
}
fn sub( val1:int!, val2:int! ): int {
   let mut work0 = 0;
   let! work1, work2 = func( val1, val2 ) {
      work1 = 0;
      work2 = 0;
   }
   then {
      work0 = 10;
   };     
   return work0 + work1 + work2;
}
print( sub( 1, 2 ) ); // 3
print( sub( nil, 2 ) ); // 0
print( sub( 1, nil ) ); // 0
print( sub( nil, nil ) ); // 0

// @lnsFront: ok
fn test( arg:int! ) {
  let mut val = 0;

  unwrap! val = arg { print( 0 ); return; } then { val = val + 1; };
  print( val );
}
test( 1 );  // print( 2 );
test( 2 );  // print( 3 );
test( nil );  // print( 0 );

Map 型データの要素にアクセスした場合、 その結果は nilable となります。

たとえば次の場合、

// @lnsFront: ok
let val = { "abc": 1 };
let val2 = val.abc;

val2 は int ではなく、 int! となります。

なぜならば、 Map 型の要素が存在しない場合、 その評価結果は nil になるためです。

ちなみに、リスト、配列の要素アクセスは nilable にはなりません。

// @lnsFront: ok
let val = [ 1, 2, 3 ];
let val2 = val[ 1 ];

上の例では、 val2 は int! ではなく int になります。

なお、 val[ 4 ] にアクセスした場合の動作は 未定義 です。

リスト、配列にインデックスでアクセスする場合は、十分注意してください。

リスト、配列のインデックスアクセス結果が nilable になるようにも考えましたが、 やり過ぎな気がしたので実施していません。

LuneScript は、次の仕様によって nil 安全を実現しています。

• nilable と非 nilable
• unwrap

次回はクラスについて説明します。

LuneScript のクラスは、次をサポートします。

• アクセス制御
• accessor
• 継承
• abstract
• override
• advertise
• Mapping
• interface

今回は基本的なクラス定義を説明します。

最小のクラス定義は次のように行ないます。

// @lnsFront: ok
class Test {
}

これは Test というクラスを定義しています。

なお、クラス定義は最上位のスコープで行なう必要があります。

(2019/6/24) 関数内でもクラス定義できるように対応しました。 ただし、外部公開可能なクラスは最上位のスコープで宣言する必要があります。

// @lnsFront: ok
pub class Test {
}

クラスのインスタンス生成は、次のように new 演算子を使用します。

// @lnsFront: ok
class Test {
}
let test = new Test();

メソッド定義は、ほぼ関数定義と同じです。

// @lnsFront: ok
class Test {
   pub fn func() {
      print( __func__ );
   }
}
let test = new Test();
test.func();  // Test.func

なお、メソッドは form 型にはセットできません。

例えば、次の sub( test.func ) はエラーします。

// @lnsFront: error
class Test {
   pub fn func() {
      print( __func__ );
   }
}
fn sub( foo:form ) {
   foo();
}

let test = new Test();
sub( test.func );  // error

これをエラーしないようにするには、 次のように anonymous 関数を作成して sub() に渡します。

// @lnsFront: ok
class Test {
   pub fn func() {
      print( __func__ );
   }
}
fn sub( foo:form ) {
   foo();
}

let test = new Test();
sub( fn() { test.func(); } );

// @lnsFront: ok
class Test {
   fn func() {
      print( __func__ );
   }
   pub fn sub() {
      self.func();
   }
}
let test = new Test();
test.sub();  // Test.func

// @lnsFront: ok
class Test {
}
pub fn Test.func() {
   print( __func__ );
}
let test = new Test();
test.func();  // Test.func

// @lnsFront: ok
class Test {
   pub fn func();
   pub fn sub() {
      self.func();
   }
}
pub fn Test.func() {
   print( __func__ );
}
let test = new Test();
test.sub();  // Test.func

// @lnsFront: ok
class Test {
   pub static fn sfunc() {
      print( __func__ );
   }
}
Test.sfunc(); // Test.sfunc

メンバ定義は、ほぼ変数定義と同じですが、次の違いがあります。

• 宣言時に初期値の設定が出来ない
• アクセス制御が追加
• accessor 指定が可能

次にメンバ定義の例を示します。

// @lnsFront: ok
class Test {
   pri let val1:int;
   pri let val2:int;
   pri let val3:int;
   pub fn func() {
      print( self.val1, self.val2, self.val3 );
   }

}
let test = new Test( 1, 2, 3 );
test.func(); // 1 2 3

クラス Test は、 val1, val2, val3 をメンバに持ちます。

val1 の定義は pri let val1:int; となっています。

これは、 これは通常の変数宣言に pri が付いただけなので問題ないと思います。

pri はアクセス制御で、意味はメソッド定義と同じです。

メンバ、メソッドにも mutable と immutable があります。

メソッドの mutable と immutable の違いは次の通りです。

• mutable なメソッドは、メンバを変更可能なメソッド
• immutable なメソッドは、メンバを変更不可能なメソッド

次に mutable なメンバ、メソッドの例を示します。

// @lnsFront: ok
class Test {
   pri let mut val1:int;
   pri let val2:int;
   pub fn func() {
      print( self.val1, self.val2 );
   }
   pub fn add( val:int ) mut {
      self.val1 = self.val1 + val;
   }
}
let mut test = new Test( 1, 2 );
test.func(); // 1 2
test.add( 10 );
test.func(); // 11 2

この例では、val1 が mutable で val2 が immutable です。 また func() が immutable で、 add() が mutable です。

mutable なメソッドは、引数宣言後に mut を宣言します。

mutable のメソッド add() は、 メンバ val1 に値をセットしています。 これはエラーせずにビルド可能です。

では、次のように メソッド add() の mut 宣言を外した場合はどうなるかというと。

// @lnsFront: error
class Test {
   pri let mut val1:int;
   pri let val2:int;
   pub fn func() {
      print( self.val1, self.val2 );
   }
   pub fn add( val:int ) {
      self.val1 = self.val1 + val;  // error
   }
}

上記の例は、エラーとなります。

mutable でないメソッド内からメンバを変更しようとした場合、エラーします。

次の場合もエラーします。

// @lnsFront: error
class Test {
   pri let mut val:int;
   pub fn increment() mut {
      self.val = self.val + 1;
   }
   pub fn func() {
      self.increment(); // error
   }
}

上記の例では、 func() から increment() をコールしていますが、 immutable なメソッドから mutable なメソッドのコールは出来ません。

前述の通り、 あるクラスのメンバが mutable であっても、 そのクラスのインスタンスが immutable である場合、 そのメンバは immutable となります。

次の例では、 func() メソッド内から mutable なメンバ val にアクセスしていますが、 func() メソッドは immutable であるため val もまた immutable となり、エラーします。

// @lnsFront: error
class Test {
   pri let mut val:int;
   pub fn func() {
      self.val = self.val + 1;  // error
   }
}

mutablity は、意図しないタイミングでの値の変化を防止するために必要な概念です。 一方で、 immutable なメソッドからはいかなるメンバも変更できない、 というのは非常に厳しいルールです。

このルールが適応されてしまうと、 例えば次のような場合、設計が難しくなってしまいます。

• キーに紐付けて、読み取り専用データを管理するクラス Data を考える
• Data クラスには、引数にキーを与えると、紐付けられたデータを返すメソッド get() を定義する
• 管理する全てのデータを登録した Data インスタンスは、不要な変更を防ぐため immutable とする

これは一般的な考え型だと思います。

そして、開発が進んでから次の仕様を追加するとします。

• 上記 get() メソッドの処理を高速化するため、 直前の引数キーと、そのキーに紐付けされたデータをキャッシュする

この「直前の引数キーと、そのキーに紐付けされたデータをキャッシュする」という処理は、 データを書き換えることになります。 つまり、 immutable ではなく mutable である必要があります。

一方で、既に Data インスタンスは多くの箇所で immutable として宣言されています。 つまり、キャッシュすることが出来ません。

このような場合に利用するのが allmut です。 allmut は、メンバの mutablity を宣言し、 インスタンスの mutablity とは独立して常に mutable となります。

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

// @lnsFront: ok
class Test {
   pri let allmut val:int;
   pub fn func() {
      self.val = self.val + 1;  // ok
   }
}

このように pri let allmut val:int; と宣言することで、 val は常に mutable となります。 これにより、 immutable なメソッド func() から、 val を書き換えることが可能となります。

ただし、allmutはあくまでも救済手段であり多用すべきではありません。

特に、後述する go での非同期プログラミングを行なう際に、 allmut があると安全性が担保されなくなります。

コンストラクタは __init で定義できます。

コンストラクタは、メソッド定義と次の点で異なります。

• コンストラクタ名は __init でなければならない。
• 戻り値の型を指定できない。
• コンストラクタの定義は、全メンバ定義の後にしなければならない。

• クラスを継承している場合、そのクラスのコンストラクタを先頭で実行しなければならない。

  • super クラスのコンストラクタの実行は super() を使用する。

• コンストラクタは、全メンバを初期化しなければならない。

  • nilable 型のメンバを明示的に初期化しない場合、 初期値 nil となります。

• コンストラクタ内の処理で全メンバを初期化してからでなければ、 そのクラスで定義するメソッドにアクセスできない。

  • ただし static メソッド、 super クラスのメソッドにはアクセス可能。
  • また、コンストラクタ内ので定義した関数オブジェクトからはメソッドにアクセス可能。
• コンストラクタ内からは、プロトタイプ宣言しただけのメソッドはコールできない。
• コンストラクタ内で return できない。

次にコンストラクタの例を示します。

// @lnsFront: ok
class Test {
   pri let val1:int;
   pri let val2:int;
   pub fn __init() {
      self.val1 = 0;
      self.val2 = 0;
   }
}
let test = new Test();

なお、コンストラクタでは immutable なメンバにも初期値を設定可能です。

// @lnsFront: ok
class Test {
   pri let val1:int;
   pri let val2:int;
   pub fn __init( val1:int, val2:int ) {
      self.val1 = val1 + 10;
      self.val2 = val2 + 10;
   }
   pub fn func() {
      print( self.val1, self.val2 );
   }
}
let test = new Test( 1, 2 );
test.func(); // 11 12

// @lnsFront: ok
class Test {
   pri let val1:int;
   pri let val2:int;
}

// @lnsFront: skip
   pub fn __init( val1:int, val2:int ) {
      self.val1 = val1;
      self.val2 = val2;
   }

// @lnsFront: ok
class Test {
   pro let val:int;
}
class Sub extend Test {
   let val2:int;
   pub fn func() {
      print( self.val, self.val2 );
   }
}
let sub = new Sub( 1, 2 );
sub.func(); // 1, 2

// @lnsFront: ok
class Test {
   pro let val:int!;
}
class Sub extend Test {
   let val2:int;
   _lune_control default__init_old;
   pub fn func() {
      print( self.val, self.val2 );
   }
}
let sub = new Sub( 2 );
sub.func(); // nil, 2

// @lnsFront: error
class Test {
   pri let mut val:int {pub};
   pub static fn create(): Test {
      return new Test( 1 );  // error
   }
}

// @lnsFront: ok
class Test {
   pri let mut val:int {pub};
   _lune_control default__init;
   pub static fn create(): Test {
      return new Test( 1 );
   }
}

クラスのインスタンスが開放されるときの処理を定義できます。

// @lnsFront: skip
class Hoge {
   fn __free() {
      print( __func__ );
   }
}
{
   let hoge = new Hoge();
}
collectgarbage(); // print Hoge

メソッドにクラスメソッドがあるように、メンバにもクラスメンバがあります。

クラスメンバの定義も static を付けるだけです。

クラスメンバの初期化は __init ブロックで行ないます。

次はクラスメンバ定義の例です。

// @lnsFront: ok
class Test {
   pri static let val1:int;
   pri static let val2:int;

   __init {
      Test.val1 = 1;
      Test.val2 = 1;
   }
}

__init ブロックは、次の制限があります。

• __init ブロックの定義は、全クラスメンバ定義の後にしなければならない。

  • nilable 型のメンバを明示的に初期化しない場合、 初期値 nil となります。
• __init ブロックは、全メンバを初期化しなければならない。
• __init ブロック内で return できない。
• __init ブロックからクラスメソッドをコールできるが、コールするクラスメソッドは、 __init ブロックより前に宣言しなければならない。

LuneScript のクラス定義は、次をサポートします。

• キーワード class でクラスを定義する
• インスタンス生成は new
• アクセス制御可能
• self シンボルで自分自身にアクセス
• クラス定義とメソッド定義を分離可能
• プロトタイプ宣言
• static でクラスメソッド、クラスメンバ
• コンストラクタは __init
• コンストラクタを作成しない場合はデフォルトコンストラクタが作られる

次回は、 accessor の生成方法について説明します。

メンバの accessor (get,set) を簡単に作成できます。

次に例を示します。

// @lnsFront: ok
class Test {
   pri let val1:int;
   pri let mut val2:int {pub,pub};
   pri let val3:int {pub};
}
let mut test = new Test( 1, 2, 3 );
print( test.$val2, test.$val3 );  // 2 3
test.set_val2( 10 );
print( test.$val2, test.$val3 );  // 10 3

上記例で val2 の定義は、 pri let val2:int {pub,pub}; としています。

この {pub,pub} は、 val2 の accessor を定義しています。 これは、 getter, setter のアクセス制御を指定します。 この指定によって、次のメソッドが内部的に作成されます。

// @lnsFront: skip
pub fn Test.get_val2(): int {
   return self.val2;
}
pub fn Test.set_val2( val:int ) {
   self.val2 = val;
}

getter にアクセスする場合、 $ を使って次のようにアクセスします。

// @lnsFront: skip
let mut test = new Test( 1, 2, 3 );
print( test.$val2, test.$val3 );  // 2 3

test.$val2 は、 test.get_val2() のシンタックスシュガーです。

上記の通り、 accessor は「getter のアクセス制御」、「setter のアクセス制御」の順で宣言します。

setter が不要な場合、「setter のアクセス制御」を省略します。

なお、getter が不要で setter が必要な場合は、次のように宣言します。

// @lnsFront: ok
class Test {
   pri let mut val1:int {non,pub};
}

この機能は、 setter を自動で生成しつつ、 getter をカスタマイズする時などに利用できます。

LuneScript の accessor は、普通のメソッドです。 C# のプロパティのような別のものではありません。

getter の戻り値型は、通常そのメンバの型と一致します。

例えば次の Test のメンバ list の getter は、 List<int> 型の戻り値を返します。

// @lnsFront: ok
class Test {
   pri let mut list:List<int> {pub};
}
let test = new Test( [] );
foreach val in test.$list { 
   print( val );
}

ここで、 List<int> 型は mutable な型であるので、 外部操作でメンバ list の値を変更できることになります。

しかし、外部操作での参照は許可しても変更を許可したくない場面が多くあります。

そのような時、 getter の戻り値型を制御することが出来ます。 制限する方法は次の 2 つあります。

• immutable な型として返す
• super クラスや interface の型として返す

// @lnsFront: ok
class Test {
   pri let mut list:List<int> {pub&};
}

// @lnsFront: ok
class Val {
}
class ValSub extend Val {
}

class Test {
   pri let val1:ValSub {pub};
   pri let val2:ValSub {pub:Val};
}
let test = new Test( new ValSub(), new ValSub() );
let val1 = test.$val1;
let val2 = test.$val2;

LuneScript の accessor は、 C# のプロパティのようなカスタマイズ機能 (単純な setter/getter ではない処理を実装する機能)は用意していません。

なぜならば、 LuneScript の accessor は、単なるメソッド宣言の簡略化機能であり、 C# のプロパティのような「別物」ではないので、 もしも独自処理を行なう accessor が必要ならばその処理を自分で作成すれば良いためです。

なお、 独自の getter を定義した場合も $ は利用できます。

$val は、 get_val() のシンタックスシュガーで、accessor 専用ということではありません。

LuneScript の accessor は次の仕様です。

• メンバ宣言と同時に宣言出来る
• getter, setter の順に宣言する
• getter にアクセスする場合、 メンバ名の前に $ を付加する。
• accessor は簡易メソッド定義であり、メソッドと異なる概念ではない。

次回は継承を説明します。

次にクラスの継承例を示します。

// @lnsFront: ok
class Super {
   pub fn func() {
      print( __func__ );
   }
}
class Sub extend Super {
}
let sub = new Sub();
sub.func(); // Super.func

これは、 Super クラスを Sub クラスが継承する例です。

継承は、クラス宣言時に extend を使用して継承する親クラスを指定します。

継承可能なクラスは 1 つだけです。

なお、コンストラクタのアクセス制御が pri の場合、 そのクラスを継承することは出来ません。

// @lnsFront: ok
class Super {
   pro let val:int;
}
class Sub extend Super {
   pub fn __init( val:int ){
      super( val );
   }
   pub fn func() {
      print( self.val );
   }
}
let sub = new Sub( 1 );
sub.func(); // 1

// @lnsFront: error
final class Super {
}
class Sub extend Super { // error
}

LuneScript は次の仕様のクラス継承をサポートします。

• 継承可能なクラスは 1 つだけ
• サブクラスは、親クラスのコンストラクタをコールしなければならない。
• 親クラスのコンストラクタ呼び出しは super() で行なう。
• super() は、コンストラクタの最初の行に各必要があ。

次回は、メソッドのオーバーライドについて説明します。

「透過的にアクセス」という表現では伝わり難いと思うので、次の例で説明します。

// @lnsFront: ok
abstract class Test {
   pub abstract fn foo(): str;
   pub abstract fn bar(): str;
}
class TestSub1 extend Test {
   pub override fn foo(): str {
      return "foo";
   }
   pub override fn bar(): str {
      return "bar";
   }
}
class TestSub2 extend Test {
   pri let sub:TestSub1;
   advertise sub;
   pub override fn bar(): str {
      return "hoge" .. self.sub.bar();
   }
}
fn func( test:Test ){
   print( test.foo(), test.bar() );
}
func( new TestSub1() ); // foo, bar
func( new TestSub2( new TestSub1() ) ); // foo, hogebar

TestSub2 は、 メンバ sub を advertise しています。

これにより TestSub2 は、 次のようにメンバ sub のメソッド (foo,bar) をコールする処理を内部的に生成します。

// @lnsFront: skip
pub override fn TestSub2.foo(): str {
   return self.sub.foo();
}
pub override fn TestSub2.bar(): str {
   return self.sub.bar();
}

この例の TestSub2 では、メソッド bar() を宣言しています。

このように宣言したメソッドと、advertise で生成されるメソッドが同名の場合、 宣言したメソッドが優先されます。

• advertise 宣言することで、メンバのメソッドを透過的にアクセスさせることが出来る
• 複数のメンバを advertise する場合は注意が必要

次回は、インタフェースについて説明します。

クラスのメソッドは全て override 可能です。

むしろ、現在は override を抑制することができません。

メソッドの override の例を次に示します。

// @lnsFront: ok
class Super {
   pub fn func() {
      print( __func__ );
   }
}
class Sub extend Super {
   pub override fn func() {
      print( __func__ );
   }
}
fn test( obj:Super ) {
   obj.func();
}
test( new Super() ); // Super.func
test( new Sub() ); // Sub.func

ここで、 Sub クラスは Super クラスの func メソッドを override しています。

override する Sub クラス側のメソッドは、 override キーワードで明示する必要があります。

override しているサブクラスから、親クラスのメソッドをコールするには、 super() を使用します。

次に super() の例を示します。

// @lnsFront: ok
class Super {
   pub fn func(): int {
      return 1;
   }
}
class Sub extend Super {
   pub override fn func(): int {
      return 10 + super();
   }
}
fn test( obj:Super ) {
   print( obj.func() );
}
test( new Sub() ); // 11

この例では、 Super クラスの func() メソッドを Sub クラスで override しています。 そして、 Sub クラスの func() から super() を使用して、 Super クラスの func() メソッドを呼び出しています。

実体を持たない abstract メソッドを定義できます。

次に abstract の例を示します。

// @lnsFront: ok
abstract class Super {
   pub abstract fn func(): int;
}
class Sub extend Super {
   pub override fn func(): int {
      return 10;
   }
}
fn test( obj:Super ) {
   print( obj.func() );
}
test( new Sub() );

この例で、 func() メソッドは実体を持たない abstract メソッドです。

なお、 abstract メソッドを持つクラスは abstract クラスとして宣言する必要があります。

abstract メソッドの実体は、 継承したクラスで定義されます。 もしも、親クラスの全ての abstract メソッドを継承したクラスで override しないと、 その継承したクラスは abstract として宣言する必要があります。

abstract クラスは、それ単体ではインスタンスを生成できなくなります。

LuneScript のメソッド override/abstract の仕様は次の通りです。

• 全てのメソッドは override 出来る
• override するクラスは、 override を明示する必要がある
• override しているメソッドから、 override 元のメソッドをコールするには super() を利用する。
• 実体の持たない abstract メソッドを宣言できる
• abstract メソッドを持つクラスは abstract クラスとなる
• abstract メソッドは、サブクラスで override しなければならない
• abstract クラスは、単体ではインスタンスを生成できない

次回は、 class の advertise について説明します。

Java や C# を使用していればお馴染だと思いますが、 インタフェースは機能が制限されたクラスと考えて問題ないです。

具体的には、インタフェースは、クラスと次の違いがあります。

• 宣言は class ではなく interface。
• メンバが持てない。
• メソッドは全て abstract。 よってインタフェース単体ではインスタンスを生成できない。
• インタフェースを実装するクラスは、extend に () を付ける
• クラスは複数のインタフェースを実装できる
• イタフェースを実装するクラスのメソッドには override を付けない。

次にインタフェースの例を示します。

// @lnsFront: ok
interface IF {
   pub fn func();
}
class Test extend (IF) {
   pub fn func() {
      print( __func__ );
   }
}
fn sub( obj:IF ) {
   obj.func();
}
sub( new Test() ); // Test.func

この例では、インタフェース IF を定義しています。

次に 2 つのインタフェースを実装するクラスの例を示します。

// @lnsFront: ok
interface IF1 {
   pub fn func1();
}
interface IF2 {
   pub fn func2();
}
class Test extend (IF1,IF2) {
   pub fn func1() {
      print( __func__ );
   }
   pub fn func2() {
      print( __func__ );
   }
}
fn sub( obj1:IF1, obj2:IF2 ) {
   obj1.func1();
   obj2.func2();
}
let mut test = new Test();
sub( test, test ); // Test.func Test.func2

複数のインタフェースを実装する場合、 extend の後に () の中に続けて宣言します。

ちなみに、複数のインタフェースを実装する場合の制限として、 次のように実装するインタフェース内に、 同名で異なる型のメソッドがある場合、エラーとなります。

// @lnsFront: error
interface IF1 {
   pub fn func():int;
}
interface IF2 {
   pub fn func():str;
}
class Test extend (IF1,IF2) { // mismatch IF1.func, IF2.func
}

なお、現在のインタフェースの仕様として、メソッドのデフォルト処理はサポートしていません。

LuneScript は、クラスの多重継承をサポートしない代わりに、 インタフェースをサポートします。

次回は、Mapping について説明します。

LuneScript は、クラスのインスタンスとマップオブジェクトとの相互変換をサポートします。

具体的には、次が可能です。

• クラスのインスタンスからマップオブジェクトの生成
• マップオブジェクトからクラスのインスタンスの生成

これによって、例えばクラスのインスタンスから JSON データを生成したり、 逆に JSON データからクラスのインスタンスを生成できます。

この機能を mapping と呼びます。

mapping を利用するには、 クラス宣言時に実装するインタフェースとして Mapping を宣言する必要があります。

次に例を示します。

// @lnsFront: ok
class Test extend (Mapping){
   let val1:int {pub};
   let val2:str {pub};
}
let test = new Test(1, "abc" );
let map = test._toMap();
print( map.val1, map.val2 ); // 1 abc
let test2 = unwrap Test._fromMap( map );
print( test2.$val1, test2.$val2 ); // 1 abc

上記の例では、 クラス Test が Mapping 実装を宣言しています。

これにより、次のメソッドが内部的に生成されます。

• fn _toMap():&Map<str,&stem>
• static fn _fromMap(map:&Map<str,&stem>):Test!,str!

_toMap() は、インスタンスからマップオブジェクトを生成するメソッドで、 _fromMap() は、マップオブジェクトからインスタンスを生成するクラスメソッドです。

なお _fromMap() は、マップオブジェクトがインスタンスを生成するための 条件を満さない場合は nil を返します。

具体的には、上記 Test の _fromMap() に、 次のマップオブジェクトを渡した場合はインスタンスが生成されますが、

{
   "val1": 1,
   "val2": "abc"
}

次のマップオブジェクトを渡した場合は、インスタンスが生成されません。

{
   "val1": 1,
   "val2": 2
}

上記マップオブジェクトの場合、本来 val2 が str であるはずが、 int になっていて不整合となるためです。

さらに _fromMap() の注意点として、 _fromMap() はメンバの型の不整合は確認しますが、値域は確認しません。

たとえば、本来取り得ない値からでも、型さえあっていればインスタンスを生成します。 ただし enum に関しては、マップオブジェクトの値が enum で定義していない値であれば、 nil を返します。

mapping によって、 クラスのインスタンスから JSON データの生成などが簡単に実現できます。

次回は、nil 条件演算子について説明します。

関数の Generics は次のように宣言します。

// @lnsFront: ok
fn func<T>( val:T ) : Set<T> {
   return (@ val);
}

上記サンプルを見ればだいたい理解できると思いますが、 関数宣言する際に 関数名 + <仮型パラメータ> で宣言します。

ここで func<T>() は、引数の値を持つ Set<T> を生成する関数です。

仮型パラメータは、複数指定することができます。

// @lnsFront: ok
fn func<T1,T2>( val1:T1, val2:T2 ) : Set<T1>, List<T2> {
   return (@ val1), [ val2 ];
}

仮型パラメータは、通常の型と同じく nilable や mutable の概念を持ちます。

これにより、次のような処理を書けます。

// @lnsFront: error
fn func1<T>( val:T ) : T {
   return val;
}
fn func2<T>( val:T ) : &T {
   return val;
}
fn func3<T>( val:T ) : T! {
   return val;
}
let mut test1 = func1( [ 1, 2 ] );
test1.insert( 1 );
let mut test2 = func2( [ 1, 2 ] );
test2.insert( 1 ); // error test2 is not mutable
let mut test3 = func3( [ 1, 2 ] );
test3.insert( 1 ); // error test3 is nilable

• func1 は、引数をそのままの型 T で返します。
• func2 は、引数を immutable 型 &T で返します。
• func3 は、引数を nilable 型 T! で返します。

これにより、 test1.insert() は可能ですが、 test2, test3 はコンパイルエラーとなります。

なお、ここで気を付けなければならないことは、 仮型パラメータを使用する時は nilable や mutable を利用できますが、 仮型パラメータ名を宣言するときは使用できません。 つまり、次のような func1<T!> はエラーとなります。

// @lnsFront: error
fn func1<T!>( val:T ) : T {
   return val;
}

また、仮型パラメータに nilable は利用できません。 つまり、次の場合エラーします。

// @lnsFront: error
fn func1<T>( val:T ) : T {
   return val;
}
let val:int! = 1;
print( func1( val ) ); // error type mismatch

この例では、 func1( val ) によって int! が func1() に与えられますが、 func1<T>(val:T) の val は T であり、 仮型パラメータは nilable を利用できないためエラーとなります。

このような処理を行なわせたい場合は、次のように宣言します。

// @lnsFront: ok
fn func1<T>( val:T! ) : T {
   return unwrap val;
}
let val:int! = 1;
print( func1( val ) ); // ok

つまり、 fn func1<T>( val:T! ) とすることで、 func1() の引数が nilable であることを宣言します。

しかし、nilable の値を扱えないと不便なこともあります。 そのような場合に備えて Nilable<T> を用意しています。

これについては、後日別途説明します。

// @lnsFront: ok
fn func<T>( val:T ) : Set<T> {
   return (@ val);
}
foreach val in func( "foo" ) {
   print( val .. "bar" );  // foobar
}
foreach val in func( 1 ) {
   print( val + 100 );  // 101
}

// @lnsFront: ok
fn func( val:stem ) : Set<stem> {
   return (@ val);
}
foreach val in func( "foo" ) {
   print( val@@str .. "bar" );
}
foreach val in func( 1 ) {
   print( val@@int + 100 );
}

クラスの Generics は次のように宣言します。

// @lnsFront: ok
class Test<T> {
   let val:T;
   pub fn func() : List<T> {
      return [ self.val ];
   }
}

クラスの場合、クラス宣言の名前を指定する際に仮型パラメータを指定します。

なお、クラス宣言の外にメソッドを宣言する場合、 次のように仮型パラメータの宣言は不要です。

// @lnsFront: skip
pub fn Test.func2() : Set<T> {
   return (@ self.val );
}

Generics クラスのインスタンスは次のように生成します。

// @lnsFront: skip
let test = new Test<str>( "abc" );

なお、コンストラクタの引数に全ての仮パラメータを使用している場合、 次のように実型パラメータを省略することも可能です。

// @lnsFront: skip
let test = new Test( "abc" );

インタフェースは generics 対応していません。

メソッドは、クラスの仮型パラメータと、メソッドの仮型パラメータを両方持てます。

次のサンプルは Test.func() メソッドは、 クラスの仮型パラメータ T と、メソッドの仮型パラメータ T2 を持っています。

// @lnsFront: ok
class Test<T> {
   let val:T;
   pub fn func<T2>(val:T2) : Map<T,T2> {
      return { self.val: val };
   }
}
let test = new Test( "abc");
foreach val, key in test.func( 1 ) {
   print( key .. "xyz", val + 10 );
}
foreach val, key in test.func( "ABC" ) {
   print( key .. "xyz", val .. "XYZ" );
}

// @lnsFront: error
class Super<T> {
   let val:T;
   pub fn func():T {
      return self.val;
   }
}
class Sub extend Super<int> {
   pub override fn func(): int { // error
      return 1;
   }
}

// @lnsFront: ok
class Super<T> {
   let val:T;
   pub fn func():T {
      return self.val;
   }
}
class Sub extend Super<A=int> {  // A=int
   pub override fn func(): A {
      return 1;
   }
}

実型パラメータには、 nil 以外の全ての型を指定できます。

このため、 Generics なクラスや関数内で仮型パラメータ型の値に対する処理は == や ~= などの型に依存しない演算に限られます。

これだと、Generics 内の処理で効果的な処理を書けません。

そこで、型パラメータの制約を利用します。

// @lnsFront: ok
abstract class Val {
   pub abstract fn func(): str;
}
class Test<T:Val> {
   let val:T;
   pub fn sub() {
      print( "this is " .. self.val.func() );
   }
}

// @lnsFront: ok
abstract class Val {
   pub abstract fn func(): str;
}
class Test<T:Val> {
   let val:T;
   pub fn sub() {
      print( "this is " .. self.val.func() );
   }
}

class Val1 extend Val {
   pub override fn func(): str {
      return "val1";
   }
}

class Val2 extend Val {
   pub override fn func(): str {
      return  "val2";
   }
}

fn func1( test:Test<Val1> ) {
   test.sub();
}
fn func2( test:Test<Val2> ) {
   test.sub();
}

func1( new Test( new Val1() ) );  // this is val1
func2( new Test( new Val2() ) );  // this is val2

// @lnsFront: skip
class Hoge<T:SuperClass(IF,...)> {
}

LuneScript は、 クラスのインスタンスを Map オブジェクトに変換する Mapping 機能を持ちます。

Mapping に関しては、次の記事を参照してください。

#classmapping

あるクラスを Mapping するには、 そのクラスが Mapping インタフェースを extend する必要があります。

次は簡単な例です。

// @lnsFront: ok
class Test<T> extend (Mapping) {
   let txt:str;
   pub fn func( val:T ) {
      print( self.txt, val );
   }
}

let test = new Test<int>( "hoge" );
let map = test._toMap();
if! let test2 = Test<int>._fromMap( map ) {
   test2.func( 1 );
}

Test<T> クラスは Mapping を extend しています。 これにより、Test<T> クラスは Mapping 可能になります。

上記の場合は、 Generics でない通常のクラスの場合と何も変りません。 これは、仮型パラメータ型のメンバに持たないためです。

次のように仮型パラメータ型のメンバを持った場合は、エラーになります。

// @lnsFront: error
class Test<T> extend (Mapping) {
   let txt:T;
}

なぜならば、あるクラスが Mapping を extend するには、 そのクラスが保持する全てのメンバが Mapping 可能でなければならないのに対し、 メンバ txt の型である仮型パラメータ T は、nilable 以外の全ての型になり得るからです。

これを回避するには、 メンバの型として使用する仮型パラメータに Mapping の制約を設定します。

具体的には次の通り Test<T:(Mapping)> とします。

// @lnsFront: ok
class Test<T:(Mapping)> extend (Mapping) {
   let val:T {pub};
}

let test = new Test( "abc" );
let map = test._toMap();
if! let test2 = Test<str>._fromMap( map ) {
   print( test2.$val .. "xyz" );
}

これにより、 Generics クラスが Mapping 可能になります。

LuneScript は 2019 年に generics をサポートしました。

一方、go が generics をサポートしたのは version 1.18 (2022年)からです。

そして、 LuneScript が go へのトランスコンパイルをサポートしたのは 2020 年で、 このころは go 1.15 の時代。

<https://twitter.com/DwarfJp/status/1317681809895780352?ref_src=twsrc>

つまり、 generics に対応していない go 1.15 で LuneScript の generics を動かしていた、ということです。

では、でどのように LuneScript の generics を実現していたか？というと、

『go の interface{} 型(現在の any 型)でデータを扱い、 アクセスする毎に interface{} からキャストして使っていた』

ということです。

具体的には、 LuneScript の collection 型には以下がありあす。

• List<T>
• Set<T>
• Map<K,V>

これらは、 go で扱う場合に次の型として定義しています。

// List<T>
type LnsList struct {
	Items       []LnsAny
	lnsItemKind int
}
// Set<T>
type LnsSet struct {
	Items map[LnsAny]bool
}
// Map<K,V>
type LnsMap struct {
	Items map[LnsAny]LnsAny
}

ここで LnsAny は interface{} です。

LuneScript v1.6.0 から、次の新しい collection 型を導入しています。

• __List<T>
• __Set<T>
• __Map<K,V>

新しい collection 型は、prefix に __ を付加します。

これらは、 go で扱う場合に次の型として定義しています。

// __List<T>
type LnsList2_[T any] struct {
	Items       []T
	lnsItemKind int
}
// __Set<T>
type LnsSet2_[T comparable] struct {
	Items map[T]bool
}
// __Map<K,V>
type LnsMap2_[K comparable,V any] struct {
	Items map[K]V
}

見ての通り、新しい collection 型では、 go の generics を利用しています。

ここでは、従来型と新しい型の特徴について説明します。

// @lnsFront: ok
let list:&List<str> = [ "abc" ];
let list2:&List<&stem> = list;
let list3:&List<str> = list2@@List<str>;

// @lnsFront: ok
fn func() {
   let code = ```
return { abc = 123 }
```;
   let obj:&stem!;
   __luago {
      if! let loaded = _load( code ## ) {
         let work = loaded(##);
         obj = expandLuavalMap( work );
      } else {
         obj = nil;
      }
   }
   when! obj {
      let map = obj@@Map<str,int>;
      foreach val, key in map {
         print( key, val );
      }
   }
}
func();

// @lnsFront: error
let list:&__List<str> = [ "abc" ];
let list2:&__List<&stem> = list; // error
let list3:&__List<str> = list2@@List<str>; // error

特に意識をしない限り、従来型の collection を使っているだけで良いです。

一方で、 go へのトランスコンパイルを利用し、 なおかつ、少しでも実行パフォーマンスを改善したい場合は、 新しい collection 型を利用します。

新しい collection 型を利用するには __List などの __ prefix を付加するだけですが、 全ての型宣言に追加をするのは大変です。 そこで、デフォルトで新しい collection を利用できるようにする方法を提供しています。

以下をコードの先頭に記載することで、 そのコード内で List を宣言した場合、 __List が指定されたものとして動作します。

_lune_control default_strict_generics;

この時、従来型の collection を利用するにはどうすれば良いかというと、 _List ("_" が 1つ)を使用します。

まとめると、以下です。

上記表では List 型について説明していますが、 他の Set, Map 型も同様です。

LuneScript の collection 型で、 go の generics を利用できるように対応しました。

この機能は実験的な要素の強い機能です。

多くの場合は、従来通りの collection 型を使うだけで問題ありません。

例えば次のような Map のデータがあった場合、

// @lnsFront: ok
let json = {
   "lv1": {
      "lv2": {
         "lv3": {
            "lv4": { 
               "lv5": {
                  "val": 1
               }           
            }        
         }     
      }  
   }
};

lv5 の val にアクセスするには、次のように処理する必要があります。

// @lnsFront: skip
if! let lv1 = json.lv1 {
   if! let lv2 = lv1.lv2 {
      if! let lv3 = lv2.lv3 {
         if! let lv4 = lv3.lv4 {
            if! let lv5 = lv4.lv5 {
               print( lv5.val );
            }        
         }     
      }  
   }  
}

あるいは次のように unwrap する必要があります。

// @lnsFront: skip
print( (unwrap (unwrap (unwrap (unwrap (unwrap json.lv1).lv2).lv3).lv4).lv5).val );

どちらにしてもイマイチです。

このようなネストされた nil チェックを簡単に行なうために利用できるのが nil 条件演算子です。

nil 条件演算子を使って上記の lv5 の val にアクセスすると、 次のようになります。

// @lnsFront: skip
print( json.lv1$.lv2$.lv3$.lv4$.lv5$.val );

だいぶスッキリします。

nil 条件演算子は、 nilable の式の直後に指定することで、 nilable の式が nil かどうかで、その後の式を実行するかどうかを制御します。

nilable の式の評価結果が nil でない場合、その後の式を実行し、 nilable の式の評価結果が nil の場合、その後の式を実行せずにその式の結果を nil とします。

なおリストにアクセスする場合は $[ 、 関数呼び出しする場合は $( となります。

次に例を示します。

// @lnsFront: ok
class Test {
   pub let val:List<int>;
   pub fn func():int {
      return 100;
   }
}
fn sub( test:Test! ) {
   print( test$.val$[1], test$.func$() );
}
sub( new Test( [ 1, 2 ] ) ); // 1 100
sub( nil ); // nil nil

上記の例では、 sub() 関数内で Test クラスの val リストと、func に nil 条件演算子を利用してアクセスしています。 これにより、 unwrap せずにアクセスすることが出来ます。

nil 条件アクセスを使用すると、必ずその評価結果は nilable になります。

次に例を示します。

// @lnsFront: ok
class Test {
   pub let val:int;
}
fn sub( test:Test! ) {
   if! test$.val {
      print( _exp + 1 );
   }
}
sub( new Test( 10 ) ); // 11

上記の場合、Test クラスの val は int です。

上記の例の sub 関数では nilable 型の Test クラスのインスタンスに対し、 test$.val でアクセスしています。 この時 test$.val の評価結果は int ではなく int! となります。

nil 条件アクセスにより、 深いネストの unwrap が簡単に出来ます。

次回は、 モジュール管理について説明します。

LuneScript のモジュール管理は、基本的に Lua と同じです。

Lua との違いを、次に挙げます。

• 特に宣言しない場合、ファイルそれぞれが 1 つのモジュールとなる。
• ファイル名の拡張子は .lns で、 .lns を除いた名前がモジュール名となる。
• init.lns は非サポート。
• LuneScript の組込みキーワード(class 等)のファイル名は非サポート。

念のため、LuneScript と Lua のモジュール管理の共通部分を説明します。

• パッケージの検索パスは package.path に格納されているパス情報によって制御される。
• モジュール名は . で区切り、サブディレクトリを表わす。
• 相互参照モジュールをサポートしない。

例えば、ファイル hoge/test.lns のモジュール名は hoge.test になります。

上記から分かるように、ディレクトリ名、ファイル名(拡張子以外)に . を含めることは出来ません。

LuneScript のソースは、特に何も宣言しなくても 1 つのモジュールとなります。

例えば、次のような Test.lns は関数 func を持つモジュールとなります。

// @lnsFront: ok
// Test.lns
fn func(): str, str {
   return __mod__, __func__;
}

ただし、モジュール内の情報を外部に公開するには、 pub 宣言が必要です。

具体的には、次のように pub を宣言する必要があります。

// @lnsFront: ok
// Test.lns
pub fn func(): str, str {
   return __mod__, __func__;
}

これによって、このモジュールの func() 関数が外部から利用できるようになります。

import は、外部モジュールの利用を宣言します。

import は、モジュールの先頭に宣言してください。

(2019/6/24) 関数内部でも宣言できるように対応しました。

上記 Test.lns を利用するには、次の様にします。

// @lnsFront: skip
import Test;

print( Test.func() ); // @Test   Test.func

上記の例では、 Test.func() で Test モジュール内の func() を呼び出しています。

このように import することで、 外部モジュールが pub 宣言しているシンボルにアクセス出来ます。

なお、work/Test.lns を import する場合は、次のようになります。

// @lnsFront: skip
import work.Test;

print( Test.func() ); // work.Test	Test.func

上記例から分かるように、import したモジュールにアクセスするには、 そのモジュール名の最後の . 以降の名前を使用します。 上記例の場合、 work.Test を import しているので、シンボル Test でアクセスします。

なお、複数モジュールを import する時に、 アクセス名が同じになる場合は(例えば foo.bar と hoge.bar を import する場合)、 次に説明する as を利用してください。

// @lnsFront: skip
import work.Test as foo;

print( foo.func() ); // work.Test	Test.func

LuneScript は、Lua のトランスコンパイラです。 つまり、 LuneScript で書いたモジュールは、 Lua から require() して使用することが出来ます。

この場合、 LuneScript で書いたモジュールは、必ずテーブルとなります。

例えば、上記 Test.lns のトランスコンパイル後の Lua ソースは、次のようになります。

--work/Test.lns
local _moduleObj = {}
local __mod__ = 'work.Test'
if not _lune then
   _lune = {}
end
local function func(  )
   local __func__ = 'Test.func'

   return __mod__, __func__
end
_moduleObj.func = func
return _moduleObj

上記のソースを見ると分かりますが、 Lua からこのソースを require() すると、_moduleObj が得られることになります。

一方で、 Lua の require() は任意の値を返すこと出来ます。 そして、この動作を期待される場合があります。

つまり、LuneScript でトランスコンパイルした Lua モジュールは、 テーブル以外のオブジェクトが得られることを期待した Lua から、 直接 require して使用することが出来ないことになります。

このような Lua モジュールとの互換を可能にする仕組みが、 provide です。

provide は、既存の Lua モジュールとの互換性を提供するものです。

Lua モジュールとの互換性が不要な場合の使用は避けてください。

次に provide の例を示します。

// @lnsFront: ok
// Test.lns
pub fn func(): str, str {
   return __mod__, __func__;
}

provide func;

上記例は、 provide に 関数 func() を与えています。

これによって、この Test.lns モジュールのトランスコンパイル結果は、 次のようになります。

--work/Test.lns
local __mod__ = 'work.Test'
if not _lune then
   _lune = {}
end
local function func(  )
   local __func__ = 'Test.func'

   return __mod__, __func__
end
return func

上記から分かるように、 Lua からこのモジュールを require() すると、 関数 func が得られます。

このように provide を利用すると、 既存の Lua モジュールとの互換性のあるモジュールを生成することが出来ます。

なお、 provide に指定できるのは シンボルだけ です。 immediate な値を指定することは出来ません。

LuneScript は、簡単にモジュールを作成でき、既存の Lua モジュールとの互換性もあります。

次回は、 LuneScript から既存の Lua モジュールを利用する方法について説明します。

Lua モジュールを扱う場合、 require() を使用します。

require() の仕様は Lua と同じですが、戻り値は stem になります。 つまり、型情報を持ちません。 適宜キャストが必要になります。

上記の通り、=require()= は stem を返します。

stem には型情報が無いため、使い勝手が悪いです。

そこで、 module 宣言を使用します。

例えば、次のような Lua のモジュール Test.lua がある場合、

local mod = {}
mod.val = 1;
function mod.func1( val )
   return val + 10
end
function mod:func2( val )
   return self.val + val
end
return mod

この Test.lua モジュールは、次の要素を持ちます。

• int の メンバ val
• 関数 func1
• メソッド func2

なお、ここで言う関数とは、呼び出す時に obj.func1() のように . で呼び出し、 メソッドとは、呼び出す時に obj:func1() のように : で呼び出すものを指します。

この Test.lua モジュールを利用する module 宣言は、次のように行ないます。

// @lnsFront: skip
module Test require 'Test'
{
   pub static let val:int;
   pub static fn func1( val:int ):int;
   pub fn func2( val:int ):int;
}
print( Test.val, Test.func1( 10 ), Test.func2( 20 ) ); // 1 20 21

まず、 module Test require 'Test' の module Test は、モジュール名 Test を宣言します。 モジュール名は通常のクラス名と考えてください。 ここでは Lua のモジュール名と同じにしましたが、違う名前でも問題ありません。

module Test require 'Test' の require 'Test' は、 どのモジュールをロードするかを指定します。 ここでは Test モジュールをロードしていることを指定しています。

残りは、通常のクラス宣言と同じです。

module 宣言したモジュールは、モジュール名でアクセスします。

// @lnsFront: skip
print( Test.val, Test.func1( 10 ), Test.func2( 20 ) );

// @lnsFront: ok
module Math require 'math' {
   pub static let pi:real;
   pub static fn sin(x:real):real;
}

print( Math.pi, Math.sin(Math.pi/2) );  // 3.1415926535898	1.0

• LuneScript は、Lua モジュールを扱えます。
• Lua モジュールを扱う方法には require() と module 宣言があります。
• module 宣言には制限があります。

次回は、マクロについて説明します。

glue を生成するには、 module 定義時に glue キーワードを指定する。

次は、 test.ext モジュールの glue を生成するサンプルである。

// @lnsFront: skip
module External require "test.ext" glue 'hoge_' {
   pub static fn create( val:int ): External;
   pub fn add( val:int ):int;
}

let obj = External.create( 1 );
print( obj.add( 10 ) ); // 11

ここで指定した "test.ext" と 'hoge_' は、 glue を生成する際に利用される。

このソースから glue コードを生成するには、次のコマンドを実行する。

$ lua lune/base/base.lua src.lns glue [dir]

ここで、 src.lns は入力元のソースで、 dir は出力先のディレクトリのパスを指定する。

このコマンドによって、次の 2 つの glue コードが生成される。

• test_ext_glue.c
• test_ext_glue.h

test_ext_glue.c は、次の内容を持つ。

#include "test_ext_glue.h"
static int lns_glue_create( lua_State * pLua );
static int lns_glue_add( lua_State * pLua );
static const char * s_full_class_name = "test_ext";
static const luaL_Reg s_lua_func_info[] = {
  { "create", lns_glue_create },
  { NULL, NULL }
};
static const luaL_Reg s_lua_method_info[] = {
  { "add", lns_glue_add },
  { NULL, NULL }
};
void * lns_glue_get_test_ext( lua_State * pLua, int index )
{
    return luaL_checkudata( pLua, index, s_full_class_name);
}

static void lns_glue_setupObjMethod(
    lua_State * pLua, const char * pName, const luaL_Reg * pReg )
{
    luaL_newmetatable(pLua, pName );
    lua_pushvalue(pLua, -1);
    lua_setfield(pLua, -2, "__index");

#if LUA_VERSION_NUM >= 502
    luaL_setfuncs(pLua, pReg, 0);

    lua_pop(pLua, 1);
#else
    luaL_register(pLua, NULL, pReg );

    lua_pop(pLua, 1);
#endif
}

void * lns_glue_new_test_ext( lua_State * pLua, size_t size )
{
    void * pBuf = lua_newuserdata( pLua, size );
    if ( pBuf == NULL ) {
        return NULL;
    }
    
#if LUA_VERSION_NUM >= 502
    luaL_setmetatable( pLua, s_full_class_name );
#else
    luaL_getmetatable( pLua, s_full_class_name );
    lua_setmetatable( pLua, -2 );
#endif

    return pBuf;
}

int luaopen_test_ext( lua_State * pLua )
{
    lns_glue_setupObjMethod( pLua, s_full_class_name, s_lua_method_info );

#if LUA_VERSION_NUM >= 502
    luaL_newlib( pLua, s_lua_func_info );
#else
    luaL_register( pLua, s_full_class_name, s_lua_func_info );
#endif
    return 1;
}
static int lns_glue_add( lua_State * pLua ){
  int val = 0;
  val = luaL_checkinteger( pLua, 2 );
  return hoge_add( pLua, val);
}
static int lns_glue_create( lua_State * pLua ){
  int val = 0;
  val = luaL_checkinteger( pLua, 1 );
  return hoge_create( pLua, val);
}

この test_ext_glue.c は、 LuneScript で定義している create() と add() のメソッドを Lua に登録するコードである。

LuneScript で定義している create() と add() に対応する関数は、 lns_glue_create() と lns_glue_add() である。

なお、この関数はそれぞれ hoge_create() と hoge_add() をコールしている。 この hoge_ は、 LuneScript のコード上で指定した glue の文字列が利用される。

test_ext_glue.h は次の内容を持つ。

#include <lauxlib.h>
extern int hoge_create( lua_State * pLua, int val );
extern int hoge_add( lua_State * pLua, int val );
extern int luaopen_test_ext( lua_State * pLua );
extern void * lns_glue_get_test_ext( lua_State * pLua, int index );
extern void * lns_glue_new_test_ext( lua_State * pLua, size_t size );

ここで、=hoge_create()= と hoge_add() は次の型となっている。

extern int hoge_create( lua_State * pLua, int val );
extern int hoge_add( lua_State * pLua, int val );

第一引数の lua_State * と戻り値の int は、 Lua の glue インタフェースと同じ意味を持つ。

第二引数の int は、 LuneScript で定義しているメソッドの引数が入る。 これは、 LuneScript で自動生成している test_ext_glue.c が Lua のスタックから値を取り出して値を設定している。

Lua の glue では、関数引数を得るため API をコールする必要があるが、 LuneScript で glue を生成した場合は、 glue コード内で関数引数を得る API を実行している。 これにより、 ユーザは関数引数を得る API をコールする必要はない。

ただし、LuneScript 側で定義しているメソッドの引数の型が int(int!), real(real!), str(str!) 型以外だった場合、 LuneScript で生成する glue では対応できないため、 別途ユーザ側での対応が必要である。

また glue の戻り値については、 ユーザ側で Lua の glue インタフェースと同じ制御を行なう必要がある。

hoge_create() と hoge_add() を別途定義することで、 test.ext モジュールが完成する。

例えば次のように定義する(glue.c)。

// glue.c
#include <test_ext_glue.h>

typedef struct {
    int val;
} glue_t;

int hoge_create( lua_State * pLua, int val )
{
    glue_t * pGlue = (glue_t*)lns_glue_new_test_ext( pLua, sizeof( glue_t ) );
    pGlue->val = val;
    return 1;
}

int hoge_add( lua_State * pLua, int val )
{
    glue_t * pGlue = lns_glue_get_test_ext( pLua, 1 );
    lua_pushinteger( pLua, val + pGlue->val );
    return 1;
}

ちなみにビルドは次のように行なう。

$ gcc -std=c99 -fPIC -shared -o test/ext.so glue.c test_ext_glue.c

LuneScript では、 _load() 関数などを利用することで LuneScript 内から Lua のコードを実行できます。

_load() 関数は、 lua の load() 関数と基本的に同じ仕様です。

以下にサンプルを示します。

// @lnsFront: ok
let code = ```
return { val1 = 10, val2 = 20 }
```;
let loaded, err = _load( code, nil );
when! loaded {
   if! let obj = loaded( ## ) {
      forsort val, key in obj@@Map<str,int> {
         print( key, val + 100 ); 
      }
   }
} else {
   print( err );
}

このサンプルは、次の値を出力します。

val1	110
val2	120

これは、Lua のコード return { val1 = 10, val2 = 20 } が返す Lua のテーブルを、 forsort で列挙して print( key, val + 100 ); で出力した結果です。

上記サンプルは、以下の LuneScript のコードとほぼ同じと言えます。

// @lnsFront: ok
fn func():Map<str,int> {
   return { "val1":10, "val2":20 };
}
forsort val, key in func() {
   print( key, val + 100 ); 
}

このように、 LuneScript と Lua は連携して動作することが出来ます。

LuneScript から Lua のコードを実行したとき、 その Lua コードの実行結果は Luaval 型になります。

Luaval 型は、Lua コード内のデータを保持する型で、 LuneScript の型 T に相当する Lua コード内のデータは Luaval<T> となります。

例えば上記サンプルの { val1 = 10, val2 = 20 } は、 LuneScritp の Map<str,int> に相当し、 Luaval<Map<str,int>> となります。

なお、 LuneScript から Lua にトランスコンパイルする場合、 Luaval<T> は T と完全に一致した型 になります。 LuneScript から Lua にトランスコンパイルする場合、 例え Luaval<T> と明示的に宣言しても内部的に T として変換されるため、 Luaval<T> を意識する必要はありません。

LuneScript から Lua 以外の言語(現在は go に変換可能)に変換する場合、 Luaval<T> と T は明確に扱いが異なるため、 Lua 以外に変換する場合は Luaval<T> を意識する必要があります。

トランスコンパイルのオプションに "–valid-luaval" を指定 することで、 Lua にトランスコンパイルする際も、Luaval<T> と T を分けて管理します。

上記サンプルは、次のように Luaval<Map<str,int>> の引数を持つ func() を使用するように書き換えることが出来ます。

// @lnsFront: ok
fn func(map:Luaval<&Map<str,int>>) {
   forsort val, key in map {
      print( key, val + 100 ); 
   }
}
let code = ```
return { val1 = 10, val2 = 20 }
```;
let loaded, err = _load( code, nil );
when! loaded {
   if! let obj = loaded( ## ) {
      func( obj@@Map<str,int> );
   }
} else {
   print( err );
}

また上記のサンプルの様に Map の Luaval 型のデータに対しても、 LuneScript の Map と同様に foreach や [] を使用した要素アクセスなどで、Map 内のデータを参照できます。 ただし参照は出来ますが、 変更は出来ません。

Luaval 型のキャストには制限があります。

上記サンプルは、次のように func の引数に obj@@Map<str,int> を渡しています。

// @lnsFront: skip   
   if! let obj = loaded( ## ) {
      func( obj@@Map<str,int> );
   }

これは obj を Map<str,int> 型にキャストする演算ですが、 ここで obj の型は Luaval<stem> 型であり、 それを Map<str,int> にキャストすると、 そのキャスト後の型は Luaval<Map<str,int>> になります。

ある型 T1 から T2 型にキャストが可能だった時、 Luaval<T1> から T2 へのキャストを指示した場合、 そのキャスト結果は Luaval<T2> になります。

また、次のキャストは出来ません。

• T1 型から Luaval<T1> 型へのキャスト
• Luaval<T1> 型から T1 型へのキャスト

具体的には Map<str,int> から Luaval<Map<str,int>> へのキャストは出来ません。

ただし、 stem 型は例外的に Luaval との相互キャストが可能です。

なお、次のように stem 型を経由することで、 Luaval 型から非 Luaval 型へのキャストが可能ですが、

Luaval => stem => Luaval

本来とは異なる型にキャストした時の動作は 未定義 です。

fn expandLuavalMap( Luaval<stem>! ) : stem!;

// @lnsFront: ok
fn func(map:Luaval<&Map<str,int>>) {
   forsort val, key in map {
      print( key, val + 100 ); 
   }
}
fn func2(map:&Map<str,int>) {
   forsort val, key in map {
      print( key, val + 100 ); 
   }
}
let code = ```
return { val1 = 10, val2 = 20 }
```;
let loaded, err = _load( code, nil );
when! loaded {
   if! let obj = loaded( ## ) {
      func( obj@@Map<str,int> );
      if! let map = expandLuavalMap( obj ) {
         func2( map@@Map<str,int> );
      }
   }
} else {
   print( err );
}

ある nilable 型の T! を保持する Luaval 型は、 Luaval<T>! になります。 Luaval<T!> にはなりません。

また、 Luaval<T> の Immutable は Luaval<&T> になります。

関数型の Luaval は、その引数、戻り値も Luaval 型になります。

例えば次のサンプルの func 関数の引数 proc は、 Luaval<Process> 型の From であり、 この Form の引数は Luaval<&List<int>> 、 戻り値は Luaval<&List<int>> になります。

// @lnsFront: skip
   form Process( val:&List<int> ) : &Map<int>;
   fn func( proc:Luaval<Process> ) {
      let list = proc( [ 1, 2, 3 ] );
   }

Lua の関数に LuneScript の値を渡す時は、Luaval 型の値を渡す必要があります。

ただし、 Lua の関数の引数が次の値の場合、 Luava 型ではなくそのままの型になります。

• int, real, bool, str
• 上記を要素に持つ List などのコレクション型
• 上記の nilable

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

// @lnsFront: ok
let code = ```
return function( tbl )
   local total = 0
   for key, val in pairs( tbl ) do
      total = total + val
   end
   return total
end
```;
let loaded, err = _load( code, nil );
when! loaded {
   if! let obj = loaded( ## ) {
   let map = { "val1":1, "val2":10 };
      print( (obj@@form)( map ) );  // Lua の関数コール
   }
} else {
   print( err );
}

このサンプルは、 引数で与えられた Lua のテーブルの要素の値の合計を計算する関数をコールします。

このサンプルでは、 Map<str,int> 型のデータ map を Lua の関数の引数に指定して実行しています。

このとき、内部的に Map<str,int> 型のデータが Lua のテーブルに変換されています。

Lua へトランスコンパイルするには、次のコマンドを実行します。

$ lnsc hello.lns save

これにより hello.lns をトランスコンパイルし、 変換後のコードを hello.lua に出力します。

この hello.lua は Lua コマンドで実行できます。

$ lua hello.lua

これを、全ての .lns ファイルに対して行なうことで、 全ての .lns ファイルをトランスコンパイルできます。

ただし、 .lns ファイルが多い場合、これだと効率が悪いです。

バッチビルドは、複数の .lns ファイルを一括でトランスコンパイルします。

複数の .lns ファイルを指定するには、 lnsc のオプションに @- を指定し、 stdin に .lns ファイルパスを渡します。 stdin に渡す .lns ファイルパスは、1 行につき 1 ファイル出力します。

例えば、 proj ディレクトリ以降の全 .lns ファイルを渡す場合、以下になります。

$ find proj -name '*.lns' | lnsc @- save

現時点で、これが最も高速に処理できる方法です。

以降は参考情報です。

$ lnsc hello.lns SAVE

$ lnsc mod1.lns --depends depends/mod1.d SAVE

test/proj/
      |
      +--- Mod1.lns
      |
      +--- Mod2.lns
      |
      +--- Mod3.lns
      |
      +--- Mod4.lns

// @lnsFront: skip
import test.proj.Mod2;

pub fn func(): str {
   return "%s -> %s" (__func__, Mod2.func() );
}
print( func() );

// @lnsFront: skip
import test.proj.Mod3;

pub fn func(): str {
   return "%s -> %s" (__func__, Mod3.func() );
}

// @lnsFront: skip
import test.proj.Mod4;

pub fn func(): str {
   return "%s -> %s" (__func__, Mod4.func() );
}

// @lnsFront: ok
pub fn func(): str {
   return __func__;
}

PROJ_DIR=test/proj
MKFILE=$(PROJ_DIR)/Makefile
SRC_DIR=$(PROJ_DIR)/

.PHONY: test all build setup

define comp
	@echo "$1 -> $2"
	lnsc $1 --depends depends/$(shell echo $1 | sed 's@/@.@g').d SAVE
endef

%.meta: %.lns
	$(call comp,$<,$@)

SRCS =
SRCS += Mod1.lns
SRCS += Mod2.lns
SRCS += Mod3.lns
SRCS += Mod4.lns

SRCS := $(addprefix $(SRC_DIR),$(SRCS))

META_LIST=$(SRCS:.lns=.meta)
LUA_LIST=$(SRCS:.lns=.lua)

-include depends/*.d

all:
	@echo make setup
	@echo make build

setup:
	mkdir -p depends

build: $(META_LIST)

make コマンドを使うことで、 LuneScript プロジェクトのビルド制御を簡単に実現できます。

LuneScript は、マクロを対応します。

もしかしたら、 最近は マクロ というよりも メタプログラミング と言った方が 意味が通り易いのかもしれません。

「マクロとは何か」を説明するには、 関数との違いを説明すると分かりやすいと思います。

関数 は、ある処理をまとめたものです。 一方、 マクロ は、複数の関数定義自体をまとめて定義することが出来ます。 もちろん マクロ として定義できるのは、 関数定義だけでなく、ほとんど全ての処理を定義できます。

マクロで一番メジャーなプログラミング言語と言えば Lisp だと思いますが、 LuneScript のマクロは Lisp ほど高機能ではありません。 しかし、 C 言語のマクロほど限定的でもありません。

// @lnsFront: ok
macro _Hello() {
   print( "hello world" );
}
_Hello(); // hello world

// @lnsFront: ok
macro _Test( val:int ) {
   {
      let name = "func%d"(val);
   }
   fn ,,,name(): int {
      return ,,val;
   }
}

_Test( 1 );
_Test( 10 );

print( func1(), func10() ); // 1  10

// @lnsFront: ok
// Test( 1 )
fn func1():int {
   return 1;
}
// Test( 10 )
fn func10():int {
   return 10;
}

// @lnsFront: skip
macro name( arg ) {
   {
      macro-statement
   }
   expand-statement
}

// @lnsFront: skip
   fn ,,,name(): int {
      return ,,val;
   }

// @lnsFront: ok
fn func1():int {
   return 1;
}

// @lnsFront: skip
   {
      let name = "func%d"(val);
   }

// @lnsFront: ok
macro _Test( val:int ) {
   {
      fn funcname(): str {
         return "func%d"(val);
      }
      let name = funcname();
   }
   fn ,,,name(): int {
      return ,,val;
   }
}

// @lnsFront: ok
macro _Test( val:int ) {
   {
      let defstat = `{
         fn ,,,"func%d"(val)~~():int {
            return ,,val;
         }
      };
   }
   ,,defstat;
}

_Test( 1 );
_Test( 10 );

print( func1(), func10() ); // 1  10

// @lnsFront: skip
      let defstat = `{
         fn ,,,"func%d"(val)~~():int {
            return ,,val;
         }
      };

// @lnsFront: ok
macro _Test( val:int ) {
   {
      let mut statList:List<stat> = [];
      for count = 1, val {
         statList.insert(
            `{          
               fn ,,,"func%d"(count)~~():int {
                  return ,,count;
               }
            } );
      }
   }
   ,,statList;
}

_Test( 5 );

print( func1(), func2(), func3(), func4(), func5() ); // 1 2 3 4 5

// @lnsFront: skip
macro name( arg ) {
   expand-statement
}

// @lnsFront: ok
pub macro _Hello() {
   print( "hello world" );
}

{
    "val1": "abc",
    "val2": 0
}

// @lnsFront: ok
class Hoge {
  pri let val1:str {pub};
  pri let val2:int {pub};
}

// @lnsFront: skip
macro _MkClass( name:str, path:str ) {
   {
      let mut memStatList:List<stat> = [];
      if! let mut fileObj = io.open( path ) {
         if! let txt = fileObj.read( "*a" ) {
            let defMap = "pub let val = %s;" (txt);
            let mod = _lnsLoad( "json", defMap );
            if! let jsonval = mod.val {
               fn getType( val:stem ): str {
                  switch type( val ) {
                     case "number" {
                        return "int";
                     }
                     case "string" {
                        return "str";
                     }
                  }
                  return "stem";
               }
               forsort val, key in jsonval@@Map<str,stem> {
                  memStatList.insert( `{
                     pri let ,,,key : ,,,getType( val )~~ {pub};
                  } );
               }
            }
         }
      }
   }
   class ,,,name {
      ,,memStatList;
   }
}
_MkClass( "Hoge", "hoge.js" );

let hoge = new Hoge( "ABC", 100 );
print( hoge.$val1, hoge.$val2 );

let mut __var:Map<str,stem>

// @lnsFront: ok
   macro _test0( name:str, val:int ) {
      {
         __var[ name ] = val;
      }
   }
   macro _test1() {
      {
         let val;
         if! let work = __var[ "hoge" ] {
            val = work@@int;
         }
         else {
            val = 10;
         }
      }
      print( "%s" (,,val) );
   }
   _test0( "hogea", 1 );
   _test1(); // 10
   _test0( "hoge", 1 );
   _test1(); // 1

LuneScript は、関数と同じ感覚でマクロを定義することが出来ます。

また、マクロを利用することで、 さまざまな処理を定義できるようになります。

次回は、 LuneScript を使って開発するプロジェクトの ビルド方法について説明します。

@@ は、変換元の値の型を実行時にチェックせずに強制的に型変換します。

// @lnsFront: ok
let val1:stem = 1;
let val2:int = val1@@int;

次のような本来変換できない値も強制的なキャストを行なえてしまいます。

// @lnsFront: ok
let val1:stem = 1;
let val2:str[] = val1@@str[];
print( #val2 ); // runtime error

上記は、 int 型の値 1 を stem 型の val1 に代入し、 それを str リスト型の val2 にキャストしています。 つまり、int 型を str リストにキャストしてしまっています。 この val2 に対してアクセスすると、 実行時エラー となります。

なお、 暗黙的に型変換が行なえるものを @@ で明示的にキャストすると、 warning となります。

例えば次のサンプルの func( "abc"@@stem ) は、 文字列 "abc" から stem への変換は明示キャスト不要で変換可能なため warning が出力されます。

// @lnsFront: ok
fn func( val:stem ) {
}
func( "abc"@@stem );

また、明らかに不正な型変換はコンパイルエラーとなります。

例えば次の場合、 1@@str は int から str に変換していますが、 この型変換は出来ないためコンパイルエラーとなります。

// @lnsFront: error
let val = "abc"@@int;  // error
let val2 = 1@@str;  // error

クラス型への @@ キャストは warning 出力します。

@@ は、 nilable から非 nilable へのキャストは出来ません。

クラス型へのキャストは @@@ か @@= を使用してください。

@@@ は、動的に変換元の型をチェックして型変換します。

次は @@@ の例です。

// @lnsFront: ok
fn func( val:stem ) {
   if! val@@@int {
      print( "int:%d" ( _exp ) );
   }
   if! val@@@str {
      print( "str:%s" ( _exp ) );
   }
}
func( 1 ); // int:1
func( "abc" ); // str:abc

val@@@int は、 val の型をチェックし int 型ならば変換し、 int 型でなければ nil を返します。 また、 val@@@str は val の型をチェックし str 型ならば変換し、 str 型でなければ nil を返します。

これにより、 func( 1 ) は int:1 を出力し、 func( "abc" ) は str:abc を出力します。

@@@ は、 キャスト元が nilable でもキャスト可能です。

// @lnsFront: ok
fn func( val:stem ) {
   if! val@@@int {
      print( "int:%d" ( _exp ) );
   }
   if! val@@@real {
      print( "real:%g" ( _exp ) );
   }
}
func( 1.0 );
func( 2.5 );

@@= は、メソッドを持たないクラスを変換する際に利用します。 メソッドを持つクラスや、クラス以外を指定した場合はコンパイルエラーします。

なお、 @@= も変換元の値をチェックせずに強制的に型変換を行ないます。

@@= は、型チェックに時間がかかるような場合に限り使用するべきです。

int、 real 間の変換以外は、 出来るだけキャストは避けるべきです。 generics や、 alge などを利用することで 型を保ったまま汎用処理を作成できます。

キャストを利用するにしても、 @@@ を利用し、 @@ や @@= の利用は必要最低限になるように設計してください。

サブファイルは 1 つの main と、複数の sub で構成される。

- main
  +- sub1
  +- sub2
  +- ...
  +- ...
  +- subN

次のように foo/bar ディレクトリ以下に、 main.lns, sub.lns が存在し sub.lns が main.lns のサブファイルの場合、

foo/bar
     + main.lns
     + sub.lns

サブファイルを利用するには、 main 側で次のように宣言する。

// @lnsFront: skip
subfile use foo.bar.sub;

また、サブファイル側では次のように宣言する。

// @lnsFront: skip
subfile owner foo.bar.main;

これにより、 指定したモジュール(上記の例では foo.bar.sub)を分割されたサブファイルとして扱い、 sub.lns は main.lns のモジュールの一部として処理する。

// @lnsFront: skip
//------ main.lns -------
subfile use sub1;
subfile use sub2;

pub let val = 1;

// @lnsFront: skip
//------ sub1.lns -------
subfile owner main;

pub let val1 = 1;

// @lnsFront: skip
//------ sub2.lns -------
subfile owner main;

pub let val2 = 1;

// @lnsFront: skip
//------ main.lns -------
pub let val = 1;
pub let val1 = 1;
pub let val2 = 1;

遅延ロードは、起動時に関連する全てのモジュールをロードするのではなく、 モジュールが必要になったタイミングでロードする処理方式です。

上記の図で説明すると、 funcA が選択された場合、 アクセスされない funcB, subB_1 〜 subB_3、 func_C, subC_1 〜 subC_3 はロードされません。

これにより、ロード処理の時間、 ロードしたデータを格納しておくメモリ領域を無駄にしません。

// @lnsFront: ok
print( "hoge" );
fn func() {
    print( "foo" );
}

// @lnsFront: skip
import Hoge;

print( "bar" );
Hoge.func();

hoge
bar
foo

bar
hoge
foo

遅延ロードは次の命令で利用できます。

• import
• module

例えば以下のようにすることで、 Sub モジュールは遅延ロードされます。

// @lnsFront: skip
import.l Sub;

import, module はコンパイルオプション依存です。

コンパイルオプションに次を指定した場合、

--default-lazy

import, module は遅延ロードになります。

なお、import.d, module.d を指定した場合は、 --default-lazy を指定している時も通常ロードになります。

shebang とは、シェルスクリプト等で良く見られるスクリプトファイルの最初の行に、 使用するインタプリタをコメントに指定することで、 そのスクリプトファイルを実行すると指定しているインタプリタが実行される機能です。 例えば bash では次のように指定します。

#! /bin/bash

LuneScript では、次のように指定します。

#! /usr/bin/lnsc -shebang

ここで、 /usr/bin/lnsc は環境に合せた指定が必要です。

これによって、 #! が記載された LuneScript ファイルをそのまま実行できます。

例えば次のようなファイル hello.lns があった場合、

#! /usr/bin/lnsc -shebang
print( "hello world" );

この hello.lns を直接実行できます。

$ hello.lns
hello world

この時、次の制限があります。

• go 版 lnsc では、 import している .lns ファイルに対応する .lua を 事前に生成しておく必要がある。

shebang で起動された場合や、 go へトランスコンパイルした場合など、 コマンドライン引数を処理したいケースがあります。

このコマンドライン引数を処理するためには、 次の __main 関数を定義し、 この関数の引数に渡されるコマンドライン引数を処理します。

// @lnsFront: skip   
pub fn __main( argList:&List<str> ):int

__main 関数の型は、 引数名 argList 以外、必ず上記の型での宣言が必要です。

#! /usr/bin/lnsc -shebang
// @lnsFront: skip   
print( "hello world" );

pub fn __main( argList:&List<str> ):int {
   print( "hoge" );
   return 0;
}

$ ./mini.lns 
hello world
hoge

#! /usr/bin/lnsc -shebang
// @lnsFront: skip   
pub fn __main( argList:&List<str> ):int {
   foreach arg in argList {
      print( arg );
   }
   return 0;
}

次の LuneScript のコードはコマンドラインオプションを出力します。

// @lnsFront: skip
pub fn __main( argList:&List<str> ) : int {
   foreach arg, index in argList {
      print( index, arg );
   }
   return 0;
}

以下は実行結果のサンプルです。

$ lnsc -shebang mini.lns a b c 
1	mini.lns
2	a
3	b
4	c

このコードをトランスコンパイラするには、次のコマンドを実行します。

lnsc mini.lns save

これによって、 mini.lua が出力されます。

この mini.lua を実行すると、以下のようになります。

$ lua5.3 mini.lua a b c

これが何を意味するかというと、「 __main() 関数が呼ばれていない 」ということです。

lnsc に -shebang オプションを指定して実行した場合、 .lns ファイルに定義されている __main() 関数を実行します。 一方で、トランスコンパイルした lua コードには __main() を実行するコードが 出力されないため、このような動作になります。

トランスコンパイルした lua コードの __main() を実行するには、次のいずれかが必要です。

• __main() を実行するコードを別途自前で作成する
• トランスコンパイルする際に --main オプションを指定する

$ lnsc mini.lns save --main mini

$ lua5.3 mini.lua a b c
1	mini.lua
2	a
3	b
4	c

ここでは以下の github リポジトリで開発することを前提として説明します。

github.com/HOGE/PROJ

• HOGE は、任意の github アカウント名。
• PROJ は、任意のリポジトリ名。

また、以下のモジュールを定義することを前提に説明します。

foo.bar.lib

ディレクトリの基本構成を示します。

PROJ/
 +-- go.mod
 +-- lune.js
 +-- foo/
   +-- bar/
      +-- lib.lns

go.mod, lune.js, foo/ を、 PROJ ディレクトリ直下に配置します。

{}

module github.com/HOGE/PROJ

go 1.16

PROJ/
 +-- src/  <--- ※任意のディレクトリ以下に配置可能
   +-- go.mod
   +-- lune.js
   +-- foo/
     +-- bar/
        +-- lib.lns

module github.com/HOGE/PROJ/src

go 1.16

${GOPATH}/src/github.com/HOGE/PROJ

go 言語へのトランスコンパイルは、 LuneScript のコマンドラインオプション save あるいは SAVE 時に -langGo を指定することで、 .go 拡張子のファイルに go へのトランスコンパイル結果を出力します。

go 言語へのトランスコンパイルを行なう場合、 Lua との連携動作を行なう際に特別な型を使用する必要があります。

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

#lua

LuneScript は Lua へのトランスコンパイラであり、 LuneScript から Lua のコードを直接利用できるという特徴があります。

この特徴は、 Go 言語へトランスコンパイルした後でも引き継がれます。

例えば、次のようなコードを Go 言語へ変換した後でも動かせます。

// @lnsFront: ok
let step = 30;

// Lua のフィボナッチ関数
let code = ```
local function fib ( n )
   if n < 2 then return n end
   return fib(n - 2) + fib(n - 1)
end
return fib
```;

// Lua コードのロード
form fibFunc( num:int ):int;
fn loadLua( txt:str ) : Luaval<fibFunc> {
   let fib;
   __luago {
      let loaded = unwrap _load( txt ## );
      fib = unwrap loaded(##);
   }
   return fib@@fibFunc;
}

// プロファイル用マクロ
macro _profile( exec:__exp ) {
   {}
   {
      let prev = os.clock();
      print( "%s = %d: step = %d: time = %g"
             (,,,,exec, ,,exec, step, os.clock() - prev ) );
   }
}

// Lua のコードをロードして実行
let fib_lua = loadLua( code );
__luago {
   _profile( fib_lua( step ) );
}

// LuneScript のフィボナッチ関数
fn fib_lns( num:int ) : int {
   if num < 2 {
      return num;
   }
   return fib_lns( num - 2 ) + fib_lns( num - 1 );
}
// Go で定義した fib_lns 関数を実行
_profile( fib_lns( step ) );

このコードは、 フィボナッチの計算を lua と LuneScript で行なうものです。

最初の code 変数で定義しているのが lua のコードで、 それをロードするのが loadLua() 関数で、ロードされた Lua の関数が fib_lua です。 そして、後半の fib_lns() 関数は フィボナッチの計算を行なう LuneScript の関数です。

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

--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

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