unwrap は、 nilable 型の式を、非 nilable 型へ変換します。

例えば次のように使用します。

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

このサンプルで val1 は int! です。その val1 を unwrap することで、 int! から int に変換しています。

なお、次のように unwrap する値が nil だった場合、 そのプログラムは実行時エラーします。

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

この実行時エラーを防ぐのが unwrap default です。 unwrap default は、変換対象の値が nil だった場合の値を指定します。

次は default を使用した例です。

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

この例では val1 は nil となるため、 default の 0 が unwrap の評価結果となります。

default のない unwrap の使用は、 確実に nil ではないと判っている時のみに限定してください。

when! は、指定の nilable 型の 変数 が nil かどうかを判定し、分岐します。

次に when! の例を示します。

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

この例では int! 型の val, val2 に対して when! で分岐しています。

• val と val2 が 非 nil の場合、 return val + val2 を実行
• val あるいは val2 が nil の場合、 return 0 を実行

when! は、指定の変数全てが非 nil の時に、最初のブロックを実行します。

このブロック内では、次の動作になります。

• 指定変数は unwrap された非 nilable の型となる。
• 指定変数は immutable となる。

when! に指定した変数のいずれかが nil だった場合、 else ブロックを実行します。 else は省略可能です。

なお、 when! に指定できるのは 変数だけ です。 メンバや式は書けません。

if! は、指定の 式 が nil かどうかを判定し、分岐します。

次に if! の例を示します。

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

この例では func() に対して if! で分岐しています。

• func() が 非 nil の場合、 return _exp + 10; を実行
• func() が nil の場合、 return 0 を実行

if! は、指定の式が非 nil だった時に、最初のブロックを実行します。 このブロック内では、式の結果を _exp としてアクセスできます。 このとき、 _exp は 非 nilable 型 です。

if! に指定した式が nil だった場合、 else ブロックを実行します。 else は省略可能です。

ちなみに、 if! で指定した式が複数の値を返す場合、 最初の戻り値だけが対象です。 2 つ目以降の戻り値は無視します。

なお、 if! は次のようなネストは出来ません。

なぜならば、 内側の if! の _exp が、外側の if! の _exp によって、 shadowing されるためです。

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

これを防ぐためには、次の if! let を使用してください。

if! let は、 if! で判定する式の結果を格納する変数名を指定可能なバージョンです。

次は if! let のサンプルです。

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

この例では if! let work1, work2 = func( val1, val2 ) を実行しています。

これは、 func() の結果を work1, work2 に代入し、 全てが非 nil だった場合に最初のブロックを実行します。 このブロック内では work1, work2 にアクセスできます。 work1, work2 は、 非 nilable 型となります。 if! let で宣言した変数のスコープは、最初のブロックです。

何れかが nilable の場合、else ブロックを実行します。 else は省略可能です。

let! は、nil 以外の初期値を持つ変数宣言を行ないます。

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

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

この例では、 let! work1, work2 = func( val1, val2 ) を実行しています。

• これは、 func() の結果を初期値とする work1, work2 を宣言しています。
• work1, work2 いずれかが nil だった場合、最初のブロックを実行します。
• 全てが非 nil だった場合、then ブロックを実行します。 then は省略可能です。

let の文には ; が必要です。 上記のサンプルでは、 then ブロック終端に }; として ; を付加されています。

最初のブロックには、次のいずれかを処理しなければならない制限があります。

• let で宣言している変数全てに値を設定する。
• let を宣言しているスコープから抜ける。

上記の例では、 work1, work2 に値を設定していますが、 return でこの関数を抜けるようにしても OK です。

なお、上記制限が守られていない場合の動作は 未定義 です。

unwrap! は、 let! に似た制御です。異なるのは変数を宣言するのではなく、 既にある変数に対して代入する点です。

次は、 unwrap! の例です。

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

上記例の val は、 int 型変数です。 この変数に、unwrap! を使って int! 型の arg を代入しています。

上記 unwrap! val = arg { print( 0 ); return; } then { val = val + 1; }; は、 次の処理を行ないます。

• arg が nil の場合、 { print( 0 ); return; } を実行する。
• arg が非 nil の場合、 arg を val に代入する。さらに then ブロックを実行する。
• then は省略可能です。