To do asynchronous processing in LuneScript, implement the __Runner interface.

The __Runner interface is of type: __async is discussed later.

// @lnsFront: skip
pub interface __Runner {
   pub fn run() __async mut;
}

By implementing this interface, you can take advantage of the new built-in functions __run(), __join().

For example, if you execute the following processing, print("hoge:", self.val ); will be processed asynchronously.

// @lnsFront: ok
class Hoge extend (__Runner) {
   let val:int;
   pub fn run() __async mut {
      print("hoge:", self.val );
   }
}

let list:List<Hoge> = [];
for index = 0, 10 {
   let mut hoge = new Hoge(index);
   __run( hoge, __lns.runMode.Sync, "" );
   list.insert( hoge );
}
foreach hoge in list {
   __join( hoge );
}

// @lnsFront: skip
pub fn __run( runner:__Runner, mode: RunMode, name:str ) : bool

// @lnsFront: skip
pub fn __join( runner:__Runner )

// @lnsFront: error
class Test {
   pub fn func() __async {
   }
}
final class Foo {
   pub fn func() __noasync {
   }
}
class Hoge extend (__Runner) {
   pub fn __init( test:Test, list:List<int>, foo:Foo ) __async { // error
   }
   pub fn run() __async mut {
   }
}

// @lnsFront: ok
class Test {
   pub fn func() __async {
   }
}
final class Foo {
   pub fn func() __noasync {
   }
}
class Hoge extend (__Runner) {
   pub fn __init( test:&Test, list:&List<int>, foo:Foo ) __async { // ok
   }
   pub fn run() __async mut {
   }
}

If you look at the definition of the run() method in the __Runner interface, you'll see that __async has been added.

This declares the function to be executable asynchronously.

LuneScript divides and manages conventional synchronous processing, which operates with only one thread, and asynchronous processing, which starts and executes a new thread.

To run a function asynchronously, you must declare the function to be asynchronously executable.

That's __async.

On the other hand, traditional synchronization is __noasyc.

Normally, I think sync is the counterpart to async, but//It is daringly set to noasync for the following reasons.

• Hard to distinguish between async and sync
• Since the subject is asynchronous processing (async) and synchronous processing is an exception, noasync

If neither __async, __noasync are declared, the default is __noasyc, but we provide a way to handle the default as __async.

Functions declared __async have the following restrictions:

• You cannot access a __noasync declared function from within a __async declared function.
• A mutable variable outside its scope cannot be accessed from within a function declared __async.

A function declared __noasync, on the other hand, has no such restriction.

This is a guard to safely perform asynchronous operations.

Asynchronous processing must consider exclusive control. If you don't do exclusive control where you need it, it becomes a bug.

See here for the necessity of exclusive control.

However, it is very difficult to manually cover all cases where exclusive control is required.

Therefore, LuneScript adopts a method that reduces omissions of exclusion control due to human error by declaring meta information in the grammar and having the compiler check for inconsistencies.

A typical language that takes this approach is Rust.

Rust achieves advanced mutual exclusion by defining strict meta information.

LuneScript does not implement as advanced exclusive control as Rust, but instead adopts relatively simple and easy-to-handle meta information definitions.

By using __asyncLock described later, it is possible to access __noasync from __async.

// @lnsFront: error
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      self.func1(); // error
   }
}

// @lnsFront: error
let mut list = [ 1, 2 ];
let list2 = [ 1, 2 ];
class Test {
   fn func() __async {
      foreach val in list { // error
         print( val );
      }
      foreach val in list2 { // ok
         print( val );
      }
   }
}

LuneScript is designed so that there are multiple (N) threads that operate asynchronously (__async) and one thread that operates with __noasync.

If there are multiple threads running on __noasync, it's no longer asynchronous, so it's only natural that there's one thread on __noasync.

As mentioned earlier, functions declared __async have limitations.

The ideal is to satisfy this limit in all cases, but in reality there are cases where this is not possible.

So we provide a way to temporarily remove the restriction on functions declared __async.

That's __asyncLock.

For example, use __asyncLock like this:

// @lnsFront: ok
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      __asyncLock {
         self.func1(); // ok
      }
   }
}

Because func2 is __async, you cannot access func2, which is __noasync by nature, but within the __asyncLock block the __async restriction is lifted.

// @lnsFront: ok
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      __asyncLock {
         self.func1();
      }
   }
   fn func3() __async {
      __asyncLock {
         self.func2();
      }
   }
}

// @lnsFront: error
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      __asyncLock {
         __asyncLock { // error
            self.func1();
         }
      }
   }
}

// @lnsFront: ok
class Test {
   fn func1() __noasync {
   }
   fn func2() __async {
      for _ = 1, 10000000 {
         __asyncLock {
            self.func1();
         }
      }
   }
}

// @lnsFront: error
class Test {
   fn func1() __noasync : bool {
      return true;
   }
   fn func2() __async : int {
      __asyncLock {
         if self.func1() {
            return 1; // error
         }
      }
      return 0;
   }
}

// @lnsFront: ok
class Test {
   fn func1() __noasync : bool {
      return true;
   }
   fn func2() __async : int {
      let mut val = 0;
      __asyncLock {
         if self.func1() {
            val = 1;
         }
      }
      return val;
   }
}

A function that declares nothing is __noasync.

We provide a way to make this default to __async .

_lune_control default_async_all

If the above is declared at the top of a .lns file, it will default to __async within that .lns file.

The features so far are summarized below.

• Multiple (N) __async threads and one __noasync thread becomes N:1.
• __asyncLock blocks while another __noasync thread is running.

From these, to do asynchronous processing in LuneScript you need:

"Basically, __Runner performs __async processing, and __noasync processing is kept to a minimum."

For example, start __Runner immediately after starting with __main(), and wait for the end of that __Runner with __join. It is basic to design.

LuneScript prevents omission of exclusive control by the following.

• Restrictions on functions declared __async
• Restrictions on constructors of classes that extend __Runner

// @lnsFront: error
let mut list = [ 1, 2 ];
class Test {
   fn func() __async {
      foreach val in list { //error
         print( val );
      }
   }
}

For example, the above access to list from func() would originally result in a compile error, but if this is not considered an error, while executing the func() method, if another thread updates the value of list, list will reference and modification occur simultaneously, resulting in undefined behavior.

To guard against this, functions declared __async are restricted.

Also, if you run code like:

// @lnsFront: error
class Hoge extend (__Runner) {
   let list:List<int>;
   pub fn __init( list:List<int> ) __async { // error
      self.list = list;

      __run( self, __lns.runMode.Queue, "test" );
   }
   pub fn run() __async mut {
      self.list.insert(1);
   }
}

let mut workList = [1];
let hoge1 = new Hoge( workList );
let hoge2 = new Hoge( workList );

Originally, the type of list in Hoge constructor is mutable, so it will cause a compilation error, but if this is not treated as an error, insert() will occur at the same time due to asynchronous processing of multiple Hoges for the same workList, resulting in undefined behavior. Become.

To guard against this, constructors that extend __Runner are restricted.

// @lnsFront: ok
let mut list = [ 1, 2 ];
let list2 = list;
class Test {
   fn func() __async {
      foreach val in list2 {
         print( val );
      }
   }
}