Renamed scheduler to process_system

Author: bryanjos

README.md

@@ -1,4 +1,4 @@
-Experiment to reproduce erlang style processes in browser. The api follows the one from Erlang. All are found on the `Scheduler` class
+Experiment to reproduce erlang style processes in browser. The api follows the one from Erlang. All are found on the `ProcessSystem` class
 
 
 ### Running Examples
@@ -13,35 +13,35 @@ to each other.
 
 #### Usage
 
-* First, import the Scheduler create a new instance of one.
+* First, import the ProcessSystem create a new instance of one.
   ```javascript
-    import { Scheduler } from "processes";
-    let scheduler = new Scheduler();
+    import { ProcessSystem } from "processes";
+    let system = new ProcessSystem();
   ```
 
-* Now you can spawn processes using the scheduler. 
+* Now you can spawn processes using the system. 
 
     A process will switch to other processes when yield is used and will run until it completes.
 
     ```javascript
-    var pid1 = scheduler.spawn(function*(){
+    var pid1 = system.spawn(function*(){
         while(true){
 
-          yield scheduler.receive(function(value){
+          yield system.receive(function(value){
             return console.log(value);
           });
 
-          scheduler.send(pid2, "message from 1");
+          system.send(pid2, "message from 1");
         }
     });
 
-    scheduler.register("Sally", pid1);
+    system.register("Sally", pid1);
 
-    var pid2 = scheduler.spawn(function*(){
+    var pid2 = system.spawn(function*(){
       while(true){
-        scheduler.send("Sally", "message from 2");
+        system.send("Sally", "message from 2");
 
-        yield scheduler.receive(function(value){
+        yield system.receive(function(value){
           return console.log(value);
         });
       }
@@ -51,7 +51,7 @@ to each other.
 
 ### API
 
-* Scheduler
+* ProcessSystem
     * `spawn(fun*) : pid` - Starts a process represented by the given generator function
     * `spawn(module, fun, args) : pid` - Starts a process using the generator function from the specified module
     * `link(pid) : void` - links the current process with the process from the given pid
@@ -76,7 +76,7 @@ to each other.
     * `erase(key)` - Removes the key and the associated value from the current process`s dictionary
     * `erase()` - Removes all entries from the current process's dictionary
 
-* `Scheduler.run(fun, args, context = null)` - A static generator function used to wrap a normal function or generator. If fun is a function, it returns the value, if it's a generator, then it delegates yielding to the generator.
+* `ProcessSystem.run(fun, args, context = null)` - A static generator function used to wrap a normal function or generator. If fun is a function, it returns the value, if it's a generator, then it delegates yielding to the generator.
 
 * GenServer
     * `start(module, args)` - Starts a GenServer with the given module and args
@@ -94,8 +94,8 @@ to each other.
 An example of a Stack using a GenServer
 
 ```javascript
-import { Scheduler, GenServer } from "processes";
-self.scheduler = self.scheduler || new Scheduler();
+import { ProcessSystem, GenServer } from "processes";
+self.system = self.system || new ProcessSystem();
 
 const Stack = {
   init: function(args){
@@ -112,16 +112,16 @@ const Stack = {
   }
 }
 
-self.scheduler.spawn(function*(){
-  const [ok, pid] = yield* Scheduler.run(GenServer.start, [Stack, ["hello"]]);
+self.system.spawn(function*(){
+  const [ok, pid] = yield* ProcessSystem.run(GenServer.start, [Stack, ["hello"]]);
 
-  let a = yield* Scheduler.run(GenServer.call, [pid, "pop"]);
+  let a = yield* ProcessSystem.run(GenServer.call, [pid, "pop"]);
   console.log(a); // "hello"
 
-  let b = yield* Scheduler.run(GenServer.cast, [pid, ["push", "world"]]);
+  let b = yield* ProcessSystem.run(GenServer.cast, [pid, ["push", "world"]]);
   console.log(b); // Symbol.for("ok")
 
-  let c = yield* Scheduler.run(GenServer.call, [pid, "pop"]);
+  let c = yield* ProcessSystem.run(GenServer.call, [pid, "pop"]);
   console.log(c); // "world"
 });
 ```

examples/gen_server.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import { Scheduler, GenServer } from "../src/processes";
-self.scheduler = self.scheduler || new Scheduler();
+import { ProcessSystem, GenServer } from "../src/processes";
+self.system = self.system || new ProcessSystem();
 
 const Stack = {
   init: function(args){
@@ -18,15 +18,15 @@ const Stack = {
   }
 }
 
-self.scheduler.spawn(function*(){
-  const [ok, pid] = yield* Scheduler.run(GenServer.start, [Stack, ["hello"]]);
+self.system.spawn(function*(){
+  const [ok, pid] = yield* ProcessSystem.run(GenServer.start, [Stack, ["hello"]]);
 
-  let a = yield* Scheduler.run(GenServer.call, [pid, "pop"]);
+  let a = yield* ProcessSystem.run(GenServer.call, [pid, "pop"]);
   console.log(a);
 
-  let b = yield* Scheduler.run(GenServer.cast, [pid, ["push", "world"]]);
+  let b = yield* ProcessSystem.run(GenServer.cast, [pid, ["push", "world"]]);
   console.log(b);
 
-  let c = yield* Scheduler.run(GenServer.call, [pid, "pop"]);
+  let c = yield* ProcessSystem.run(GenServer.call, [pid, "pop"]);
   console.log(c);
 });

examples/send_receive.js

@@ -1,29 +1,29 @@
 "use strict";
 
-import { Scheduler, GenServer } from "../src/processes";
-self.scheduler = self.scheduler || new Scheduler();
+import { ProcessSystem, GenServer } from "../src/processes";
+self.system = self.system || new ProcessSystem();
 
 
-var pid1 = scheduler.spawn(function*(){
+var pid1 = system.spawn(function*(){
     while(true){
 
-      yield scheduler.receive(function(value){
+      yield system.receive(function(value){
         return console.log(value);
       });
 
-      scheduler.send(pid2, "message from 1");
+      system.send(pid2, "message from 1");
     }
 });
 
-scheduler.register("Sally", pid1);
+system.register("Sally", pid1);
 
 
-var pid2 = scheduler.spawn(function*(){
+var pid2 = system.spawn(function*(){
   while(true){
 
-    scheduler.send("Sally", "message from 2");
+    system.send("Sally", "message from 2");
 
-    yield scheduler.receive(function(value){
+    yield system.receive(function(value){
       return console.log(value);
     });
   }

src/processes.js

@@ -1,3 +1,3 @@
-export { default as Scheduler } from "./processes/scheduler";
+export { default as ProcessSystem } from "./processes/process_system";
 export { default as GenServer } from "./processes/otp/gen_server";
 export { default as GenEvent } from "./processes/otp/gen_event";

src/processes/otp/gen_event.js

@@ -1,15 +1,15 @@
 function start(options = []){
-  return [Symbol.for("ok"), self.scheduler.spawn(start_process())];
+  return [Symbol.for("ok"), self.system.spawn(start_process())];
 }
 
 function start_link(options = []){
-  return [Symbol.for("ok"), self.scheduler.spawn_link(start_process())];
+  return [Symbol.for("ok"), self.system.spawn_link(start_process())];
 }
 
 function start_process(){
   return function*(){
     while(true){
-      yield self.scheduler.receive(function(args){
+      yield self.system.receive(function(args){
         switch(args[0]){
           case "add_handler":
             break;

src/processes/otp/gen_server.js

@@ -1,40 +1,40 @@
 function start(module, args){
-  return [Symbol.for("ok"), self.scheduler.spawn(start_process(module, args))];
+  return [Symbol.for("ok"), self.system.spawn(start_process(module, args))];
 }
 
 function start_link(module, args){
-  return [Symbol.for("ok"), self.scheduler.spawn_link(start_process(module, args))];
+  return [Symbol.for("ok"), self.system.spawn_link(start_process(module, args))];
 }
 
 function start_process(module, args){
   return function*(){
     let [ok, state] = module.init.apply(null, [args]);
-    yield self.scheduler.put("state", state);
+    yield self.system.put("state", state);
 
     try{
       while(true){
-        yield self.scheduler.receive(function(args){
+        yield self.system.receive(function(args){
           let command = args[0];
 
           switch(command){
             case "call":
               var request = args[1];
               var sender = args[2];
 
-              var [reply, response, new_state] = module.handle_call(request, sender, self.scheduler.get("state"));
-              self.scheduler.put("state", new_state);
+              var [reply, response, new_state] = module.handle_call(request, sender, self.system.get("state"));
+              self.system.put("state", new_state);
 
-              self.scheduler.send(sender, response);
+              self.system.send(sender, response);
               break;
 
             case "cast":
               var request = args[1];
               var sender = args[2];
 
-              var [reply, new_state] = module.handle_cast(request, self.scheduler.get("state"));
+              var [reply, new_state] = module.handle_cast(request, self.system.get("state"));
 
-              self.scheduler.put("state", new_state);
-              self.scheduler.send(args[2], Symbol.for("ok"));
+              self.system.put("state", new_state);
+              self.system.send(args[2], Symbol.for("ok"));
 
               break;
 
@@ -52,23 +52,23 @@ function start_process(module, args){
 }
 
 function* call(server, request){
-  self.scheduler.send(server, ["call", request, self.scheduler.pid()]);
+  self.system.send(server, ["call", request, self.system.pid()]);
 
-  return yield self.scheduler.receive(function(args){
+  return yield self.system.receive(function(args){
     return args;
   });
 }
 
 function* cast(server, request){
-  self.scheduler.send(server, ["cast", request, self.scheduler.pid()]);
+  self.system.send(server, ["cast", request, self.system.pid()]);
 
-  return yield self.scheduler.receive(function(args){
+  return yield self.system.receive(function(args){
     return args;
   });  
 }
 
-function stop(server, request){
-  self.scheduler.send(server, ["stop"]); 
+function stop(server){
+  self.system.send(server, ["stop"]); 
 }
 
 export default { start, start_link, call, cast, stop };

src/processes/process.js

@@ -2,7 +2,7 @@
 
 /* @flow */
 import Mailbox from "./mailbox";
-import Scheduler from "./scheduler";
+import ProcessSystem from "./process_system";
 import States from "./states";
 
 const NOMSG = Symbol();
@@ -24,17 +24,17 @@ class Process {
   mailbox: Mailbox;
   func: Function;
   args: Array;
-  scheduler: Scheduler;
+  system: ProcessSystem;
   status: Symbol;
   dict: Object;
   flags: Object;
 
-  constructor(pid: Number, func: Function, args: Array, mailbox: Mailbox, scheduler: Scheduler){
+  constructor(pid: Number, func: Function, args: Array, mailbox: Mailbox, system: ProcessSystem){
     this.pid = pid;
     this.func = func;
     this.args = args;
     this.mailbox = mailbox;
-    this.scheduler = scheduler;
+    this.system = system;
     this.status = States.STOPPED;
     this.dict = {};
     this.flags = {};
@@ -44,8 +44,8 @@ class Process {
     const function_scope = this;
     let machine = this.main();
 
-    this.scheduler.queue(function() {
-      function_scope.scheduler.set_current(function_scope.pid); 
+    this.system.queue(function() {
+      function_scope.system.set_current(function_scope.pid); 
       function_scope.run(machine, machine.next()); 
     }, this.pid);  
   }
@@ -60,7 +60,7 @@ class Process {
       retval = e;
     }
 
-    this.scheduler.exit(retval);
+    this.system.exit(retval);
   }
 
   process_flag(flag, value){
@@ -76,7 +76,7 @@ class Process {
       console.error(reason);
     }
 
-    this.scheduler.remove_proc(this.pid, reason);
+    this.system.remove_proc(this.pid, reason);
   }
 
   receive(fun){
@@ -103,17 +103,17 @@ class Process {
 
       if(is_sleep(value)){
 
-        this.scheduler.delay(function() {
-          function_scope.scheduler.set_current(function_scope.pid); 
+        this.system.delay(function() {
+          function_scope.system.set_current(function_scope.pid); 
           function_scope.run(machine, machine.next()); 
         }, value[1]);
 
       }else if(is_receive(value) && receive_timed_out(value)){
 
         let result = value[3]();
 
-        this.scheduler.queue(function() { 
-          function_scope.scheduler.set_current(function_scope.pid); 
+        this.system.queue(function() { 
+          function_scope.system.set_current(function_scope.pid); 
           function_scope.run(machine, machine.next(result)); 
         });
 
@@ -122,20 +122,20 @@ class Process {
         let result = function_scope.receive(value[1]);
 
         if(result === NOMSG){
-          this.scheduler.suspend(function() { 
-            function_scope.scheduler.set_current(function_scope.pid); 
+          this.system.suspend(function() { 
+            function_scope.system.set_current(function_scope.pid); 
             function_scope.run(machine, step); 
           });         
         }else{
-          this.scheduler.queue(function() { 
-            function_scope.scheduler.set_current(function_scope.pid); 
+          this.system.queue(function() { 
+            function_scope.system.set_current(function_scope.pid); 
             function_scope.run(machine, machine.next(result)); 
           });          
         }
 
       }else{
-        this.scheduler.queue(function() { 
-          function_scope.scheduler.set_current(function_scope.pid); 
+        this.system.queue(function() { 
+          function_scope.system.set_current(function_scope.pid); 
           function_scope.run(machine, machine.next(value)); 
         });  
       }