unwrap converts an expression of type nilable to a non-nilable type.

For example:

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

val1 is int! in this example. By unwrapping that val1, we are converting from int! to int.

If the unwrap value is nil as shown below, the program will generate an error at runtime.

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

The unwrap default prevents this run-time error. unwrap default specifies the value if the value being converted is nil.

Here is an example using default :

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

In this example, val1 is nil, so 0 in default is the result of unwrap evaluation.

Only use unwrap without a default when you know for sure that it's not nil.

when! determines whether the specified nilable type variable is nil and branches.

Here is an example of 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

In this example, when! branches for int! type val and val2.

• If val and val2 are non-nil, do return val + val2
• if val or val2 is nil, do return 0

when! executes the first block when all specified variables are non-nil.

Within this block, the following behavior occurs:

• The specified variable will be of unwrapped non-nilable type.
• Specified variables are immutable.

If any of the variables specified in when! is nil, execute the else block. else is optional.

Note that when! can only be variables. You cannot write members or expressions.

if! determines whether the given expression is nil and branches.

Here is an example of 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

In this example, if! is branched to func().

• If func() is non-nil, do return _exp + 10;
• If func() is nil, do return 0

if! executes the first block when the specified expression is non-nil. Inside this block, you can access the result of the expression as _exp. Then _exp is of non-nilable type.

If the expression given to if! is nil, execute the else block. else is optional.

By the way, if the expression specified with if! returns multiple values, only the first return value is considered. Ignore the second and subsequent return values.

Note that if! cannot be nested like this:

Because the _exp of the inner if! is shadowed by the _exp of the outer if!.

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

To prevent this, use the following if! let .

if! let is a version that allows you to specify a variable name to store the result of the expression tested by if!.

Here is a sample 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

In this example we are running if! let work1, work2 = func( val1, val2 ).

This assigns the result of func() to work1, work2 and executes the first block if all are non-nil. You can access work1, work2 inside this block. work1, work2 are non-nilable types. The scope of variables declared with if! let is the first block.

If either is nilable, execute the else block. else is optional.

let! declares variables with non-nil initial values.

Here is a sample 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

In this example, we are running let! work1, work2 = func( val1, val2 ).

• This declares work1 and work2 with initial values of the result of func().
• If either work1, work2 is nil, execute the first block.
• If all are non-nil, then execute the block. then is optional.

; is required in the let statement. In the above sample, ; is added as }; at the end of the then block.

The first block has restrictions that must handle one of the following:

• Set values for all variables declared with let.
• Exit the scope that declares let.

In the above example, values are set to work1 and work2, but it is OK to exit this function with return.

The behavior is undefined if the above restrictions are not followed.

unwrap! is a let! -like control. The difference is that instead of declaring a variable, you assign it to an existing variable.

Here is an example of 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 in the above example is an int type variable. This variable is assigned arg of type int! using unwrap!.

The above unwrap! val = arg { print( 0 ); return; } then { val = val + 1; }; does the following:

• If arg is nil, execute { print( 0 ); return; }.
• If arg is non-nil, assigns arg to val. Execute more then blocks.
• then is optional.