rename top-level spawn -> main

index.d.ts

@@ -25,7 +25,7 @@ declare module "effection" {
     context: Context;
   }
 
-  export function spawn(operation: Operation): Context;
+  export function main(operation: Operation): Context;
 
   export function fork(operation: Operation): Operation;
 

src/index.js

@@ -3,7 +3,7 @@ export { fork, join } from './control';
 
 import { ExecutionContext } from './context';
 
-export function spawn(operation) {
+export function main(operation) {
   let top = new ExecutionContext();
   top.enter(operation);
   return top;

tests/async.test.js

@@ -4,14 +4,14 @@
 
 import expect from 'expect';
 
-import { spawn, fork, join } from '../src/index';
+import { main, fork, join } from '../src/index';
 
 describe('Async executon', () => {
   describe('with asynchronously executing children', () => {
     let execution, one, two, three;
 
     beforeEach(() => {
-      execution = spawn(function* outer() {
+      execution = main(function* outer() {
         one = yield fork();
 
         two = yield fork();
@@ -122,7 +122,7 @@ describe('Async executon', () => {
     let execution, one, two, three, sync, boom;
     beforeEach(() => {
       boom = new Error('boom!');
-      execution = spawn(function*() {
+      execution = main(function*() {
         one = yield fork();
         two = yield fork();
         yield function*() {
@@ -250,7 +250,7 @@ describe('Async executon', () => {
   describe('A parent that block, but also has an async child', () => {
     let parent, child;
     beforeEach(() => {
-      parent = spawn(function*() {
+      parent = main(function*() {
         child = yield fork();
         yield x => x;
       });
@@ -286,7 +286,7 @@ describe('Async executon', () => {
   describe('joining a fork', () => {
     let root, child, getNumber;
     beforeEach(() => {
-      root = spawn(function*() {
+      root = main(function*() {
         child = yield fork(function*() {
           getNumber = yield fork();
           let number = yield join(getNumber);

tests/controller.test.js

@@ -2,7 +2,7 @@
 
 import expect from 'expect';
 
-import { spawn } from '../src/index';
+import { main } from '../src/index';
 
 import mock from 'jest-mock';
 
@@ -22,7 +22,7 @@ describe('Controlling execution', () => {
     beforeEach(() => {
       relinquish = mock.fn();
 
-      execution = spawn(function*() {
+      execution = main(function*() {
         yield control;
       });
 
@@ -70,7 +70,7 @@ describe('Controlling execution', () => {
   describe('from an intermediate step in an execution', () => {
     beforeEach(() => {
       relinquish = mock.fn();
-      spawn(function* () {
+      main(function* () {
         yield control;
         yield ctl => ctl.resume();
       });
@@ -86,7 +86,7 @@ describe('Controlling execution', () => {
   describe('a release function that throws an error', () => {
     beforeEach(() => {
       relinquish = () => { throw new Error('this is a bug in the release control!'); };
-      spawn(function* () {
+      main(function* () {
         yield control;
       });
     });

tests/execution.test.js

@@ -1,14 +1,14 @@
 import expect from 'expect';
 import mock from 'jest-mock';
-import { spawn, join, fork } from '../src/index';
+import { main, join, fork } from '../src/index';
 
 describe('execution', () => {
 
   describe('raw functions that resume immediately', () => {
     let exec, exit;
     beforeEach(() => {
       exit = mock.fn();
-      exec = spawn(({ resume, ensure }) => {
+      exec = main(({ resume, ensure }) => {
         ensure(exit);
         resume(1234);
       });
@@ -27,7 +27,7 @@ describe('execution', () => {
     let exec, exit;
     beforeEach(() => {
       exit = mock.fn();
-      exec = spawn(({ fail, ensure }) => {
+      exec = main(({ fail, ensure }) => {
         ensure(exit);
         fail(new Error('boom!'));
       });
@@ -49,7 +49,7 @@ describe('execution', () => {
     let exec, resume, fail;
 
     beforeEach(() => {
-      exec = spawn(join(spawn(context => ({ resume, fail } = context))));
+      exec = main(join(main(context => ({ resume, fail } = context))));
     });
     it('is still running', () => { //invariant
       expect(exec.isRunning).toBe(true);
@@ -81,7 +81,7 @@ describe('execution', () => {
     let exec, resume, fail;
 
     beforeEach(() => {
-      exec = spawn(fork(context => ({ resume, fail } = context)));
+      exec = main(fork(context => ({ resume, fail } = context)));
     });
 
     it('makes the external process waiting and blocking', () => {

tests/fork-as-promise.test.js

@@ -1,7 +1,7 @@
 import expect from 'expect';
 import mock from 'jest-mock';
 
-import { spawn, fork } from '../src/index';
+import { main, fork } from '../src/index';
 
 const HALT = expect.stringContaining('Interrupted');
 async function suspend() {}
@@ -10,7 +10,7 @@ describe('forks as promises', () => {
   let root, child, awaken;
 
   beforeEach(async () => {
-    root = spawn(function*() {
+    root = main(function*() {
       child = yield fork();
       return yield ({ resume }) => awaken = resume;
     });

tests/generator-syntax.test.js

@@ -5,7 +5,7 @@
 import expect from 'expect';
 import mock from 'jest-mock';
 
-import { spawn } from '../src/index';
+import { main } from '../src/index';
 
 describe('Co-routine guarantees', () => {
   let top, inner, error;
@@ -15,7 +15,7 @@ describe('Co-routine guarantees', () => {
 
     finalizeTop = mock.fn();
     finalizeMiddle = mock.fn();
-    top = spawn(function* top() {
+    top = main(function* top() {
       try {
         return yield function* middle() {
           try {
@@ -132,7 +132,7 @@ describe('Co-routine guarantees', () => {
 describe('deeply nested task that throws an error', () => {
   let execution, error;
   beforeEach(() => {
-    execution = spawn(function*() {
+    execution = main(function*() {
       try {
         return yield function*() {
           return yield function*() {
@@ -162,7 +162,7 @@ describe('executing a generators', () => {
   describe('nested inside generator functions', () => {
     beforeEach(() => {
 
-      execution = spawn(function*() {
+      execution = main(function*() {
         let one = yield function*() { return 1; };
         let two = yield function*() { return 2; };
         return yield add(one, two);
@@ -177,7 +177,7 @@ describe('executing a generators', () => {
 
   describe('directly', () => {
     beforeEach(() => {
-      execution = spawn(add(1, 2));
+      execution = main(add(1, 2));
     });
     it('computes the result just fine', () => {
       expect(execution.isCompleted).toEqual(true);

tests/promise-of.test.js

@@ -1,14 +1,14 @@
 import expect from 'expect';
 
-import { spawn } from '../src/index';
+import { main } from '../src/index';
 
 describe('yielding on a promise', () => {
   let execution, deferred, error;
 
   beforeEach(() => {
     error = undefined;
     deferred = new Deferred();
-    execution = spawn(function*() {
+    execution = main(function*() {
       try {
         return yield deferred.promise;
       } catch (e) {

tests/root.test.js

@@ -4,13 +4,13 @@
 
 import expect from 'expect';
 
-import { spawn, fork } from '../src/index';
+import { main, fork } from '../src/index';
 
 describe('Root', () => {
   let execution, child, grandchild;
 
   beforeEach(() => {
-    execution = spawn(function* () {
+    execution = main(function* () {
       child = yield fork(function*() {
         grandchild = yield fork();
       });

tests/spawn.test.js

@@ -1,11 +1,11 @@
 import expect from 'expect';
-import { spawn } from '../src/index';
+import { main } from '../src/index';
 
 describe('spawning operations', () => {
   describe('with default resume/fail', () => {
     let context, child, resolve, reject;
     beforeEach(() => {
-      context = spawn(({ spawn }) => {
+      context = main(({ spawn }) => {
         child = spawn(({ resume, fail }) => {
           resolve = resume;
           reject = fail;

types/execute.test.ts

@@ -1,20 +1,20 @@
-import { Context, Sequence, spawn, fork } from 'effection';
+import { Context, Sequence, main, fork } from 'effection';
 
 function* operation(): Sequence {}
 
 let execution: Context;
 
-execution = spawn(fork(operation));
+execution = main(fork(operation));
 
-execution = spawn(operation());
+execution = main(operation());
 
-execution = spawn(Promise.resolve("hello world"));
+execution = main(Promise.resolve("hello world"));
 
-execution = spawn(function*() {});
+execution = main(function*() {});
 
-execution = spawn(undefined);
+execution = main(undefined);
 
-execution = spawn(({ resume, fail, ensure, context }) => {
+execution = main(({ resume, fail, ensure, context }) => {
   context.id;
   resume(10);
   context.halt();

types/promise.test.ts

@@ -1,16 +1,16 @@
-import { spawn } from 'effection';
+import { main } from 'effection';
 
 async function someAsyncFunction() {
-  await spawn(function*() {
+  await main(function*() {
     yield
   });
 
   await Promise.all([
-    spawn(function*() { yield }),
-    spawn(function*() { yield }),
+    main(function*() { yield }),
+    main(function*() { yield }),
   ]);
 
-  let someFork = spawn(function*() {
+  let someFork = main(function*() {
     yield
     return 123;
   });