@turing-machine-js/machine 2.0.0-alpha.1 → 2.0.0

package/dist/classes/Lock.d.ts

@@ -0,0 +1,6 @@
+export default class Lock {
+    #private;
+    lock(symbol: symbol): void;
+    unlock(symbol: symbol): void;
+    check(symbol: symbol | null): void;
+}

package/dist/classes/Lock.js

@@ -0,0 +1,34 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _Lock_lockSymbol;
+class Lock {
+    constructor() {
+        _Lock_lockSymbol.set(this, null);
+    }
+    lock(symbol) {
+        if (__classPrivateFieldGet(this, _Lock_lockSymbol, "f") === null) {
+            __classPrivateFieldSet(this, _Lock_lockSymbol, symbol, "f");
+        }
+    }
+    unlock(symbol) {
+        if (__classPrivateFieldGet(this, _Lock_lockSymbol, "f") === symbol) {
+            __classPrivateFieldSet(this, _Lock_lockSymbol, null, "f");
+        }
+    }
+    check(symbol) {
+        if (__classPrivateFieldGet(this, _Lock_lockSymbol, "f") && __classPrivateFieldGet(this, _Lock_lockSymbol, "f") !== symbol) {
+            throw new Error('Lock check failed');
+        }
+    }
+}
+_Lock_lockSymbol = new WeakMap();
+export default Lock;

package/dist/classes/State.js

@@ -93,7 +93,7 @@ class State {
         if (__classPrivateFieldGet(this, _State_symbolToDataMap, "f").has(symbol)) {
             return __classPrivateFieldGet(this, _State_symbolToDataMap, "f").get(symbol).command;
         }
-        throw new Error(`No command for symbol at state named ${__classPrivateFieldGet(this, _State_id, "f")}`);
+        throw new Error(`No command for symbol at state named ${__classPrivateFieldGet(this, _State_name, "f")}`);
     }
     getNextState(symbol) {
         if (__classPrivateFieldGet(this, _State_symbolToDataMap, "f").has(symbol)) {

package/dist/classes/TapeBlock.d.ts

@@ -1,25 +1,28 @@
 import Alphabet from './Alphabet';
 import Command from './Command';
 import Tape from './Tape';
+import Lock from './Lock';
 declare const symbolToPatternListMapSymbol: unique symbol;
+export declare const lockSymbol: unique symbol;
 type PatternList = (string | symbol)[][];
 type SymbolToPatternListMap = Map<symbol, PatternList>;
 export default class TapeBlock {
     #private;
-    static fromAlphabets: (alphabets: Alphabet[]) => TapeBlock;
-    static fromTapes: (tapes: Tape[]) => TapeBlock;
     private constructor();
     get alphabets(): Alphabet[];
     get currentSymbols(): string[];
+    get [lockSymbol](): Lock;
     get symbol(): (symbols: (symbol | string)[] | symbol | string) => symbol;
     get tapes(): Tape[];
-    applyCommand(command: Command): void;
+    set [symbolToPatternListMapSymbol](symbolToPatternListMap: SymbolToPatternListMap);
+    static fromAlphabets: (alphabets: Alphabet[]) => TapeBlock;
+    static fromTapes: (tapes: Tape[]) => TapeBlock;
+    applyCommand(command: Command, executionSymbol?: symbol | null): void;
     clone(cloneTapes?: boolean): TapeBlock;
     isMatched({ currentSymbols, symbol }: {
         currentSymbols?: string[];
         symbol: symbol;
     }): boolean;
     replaceTape(tape: Tape, tapeIx?: number): void;
-    [symbolToPatternListMapSymbol]: (symbolToPatternListMap: SymbolToPatternListMap) => void;
 }
 export {};

package/dist/classes/TapeBlock.js

@@ -9,18 +9,18 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _a, _TapeBlock_symbolToPatternListMap, _TapeBlock_tapes, _TapeBlock_generateSymbolHint, _TapeBlock_buildPatternList, _TapeBlock_getSymbolForPatternList, _TapeBlock_symbol, _b;
+var _a, _TapeBlock_symbolToPatternListMap, _TapeBlock_lock, _TapeBlock_tapes, _TapeBlock_generateSymbolHint, _TapeBlock_buildPatternList, _TapeBlock_getSymbolForPatternList, _TapeBlock_symbol;
 import Tape from './Tape';
 import { ifOtherSymbol } from './State';
 import { movements, symbolCommands } from './TapeCommand';
+import Lock from './Lock';
 const symbolToPatternListMapSymbol = Symbol('symbol for symbolToPatternListMap setter');
+export const lockSymbol = Symbol('capture symbol');
 class TapeBlock {
     constructor(argument) {
         _TapeBlock_symbolToPatternListMap.set(this, new Map());
+        _TapeBlock_lock.set(this, new Lock());
         _TapeBlock_tapes.set(this, void 0);
-        this[_b] = (symbolToPatternListMap) => {
-            __classPrivateFieldSet(this, _TapeBlock_symbolToPatternListMap, new Map(symbolToPatternListMap), "f");
-        };
         _TapeBlock_buildPatternList.set(this, (symbolList) => symbolList.reduce((result, symbol, ix) => {
             const row = Math.floor(ix / __classPrivateFieldGet(this, _TapeBlock_tapes, "f").length);
             if (!Array.isArray(result[row])) {
@@ -104,13 +104,20 @@ class TapeBlock {
     get currentSymbols() {
         return __classPrivateFieldGet(this, _TapeBlock_tapes, "f").map((tape) => tape.symbol);
     }
+    get [(_TapeBlock_symbolToPatternListMap = new WeakMap(), _TapeBlock_lock = new WeakMap(), _TapeBlock_tapes = new WeakMap(), _TapeBlock_buildPatternList = new WeakMap(), _TapeBlock_getSymbolForPatternList = new WeakMap(), _TapeBlock_symbol = new WeakMap(), lockSymbol)]() {
+        return __classPrivateFieldGet(this, _TapeBlock_lock, "f");
+    }
     get symbol() {
         return __classPrivateFieldGet(this, _TapeBlock_symbol, "f").bind(this);
     }
     get tapes() {
         return [...__classPrivateFieldGet(this, _TapeBlock_tapes, "f")];
     }
-    applyCommand(command) {
+    set [symbolToPatternListMapSymbol](symbolToPatternListMap) {
+        __classPrivateFieldSet(this, _TapeBlock_symbolToPatternListMap, new Map(symbolToPatternListMap), "f");
+    }
+    applyCommand(command, executionSymbol = null) {
+        __classPrivateFieldGet(this, _TapeBlock_lock, "f").check(executionSymbol);
         if (__classPrivateFieldGet(this, _TapeBlock_tapes, "f").length !== command.tapesCommands.length) {
             throw new Error('invalid command');
         }
@@ -150,11 +157,11 @@ class TapeBlock {
         else {
             tapeBlock = _a.fromAlphabets(this.alphabets);
         }
-        tapeBlock[symbolToPatternListMapSymbol](__classPrivateFieldGet(this, _TapeBlock_symbolToPatternListMap, "f"));
+        tapeBlock[symbolToPatternListMapSymbol] = __classPrivateFieldGet(this, _TapeBlock_symbolToPatternListMap, "f");
         return tapeBlock;
     }
     isMatched({ currentSymbols = this.currentSymbols, symbol }) {
-        var _c;
+        var _b;
         if (symbol === ifOtherSymbol) {
             return true;
         }
@@ -162,9 +169,9 @@ class TapeBlock {
             throw new Error('invalid symbol');
         }
         const patternList = __classPrivateFieldGet(this, _TapeBlock_symbolToPatternListMap, "f").get(symbol);
-        return (_c = patternList === null || patternList === void 0 ? void 0 : patternList.some((pattern) => (pattern
+        return (_b = patternList === null || patternList === void 0 ? void 0 : patternList.some((pattern) => (pattern
             .every((everySymbol, ix) => (everySymbol === ifOtherSymbol
-            || everySymbol === currentSymbols[ix]))))) !== null && _c !== void 0 ? _c : false;
+            || everySymbol === currentSymbols[ix]))))) !== null && _b !== void 0 ? _b : false;
     }
     replaceTape(tape, tapeIx = 0) {
         if (__classPrivateFieldGet(this, _TapeBlock_tapes, "f")[tapeIx] == null) {
@@ -178,14 +185,14 @@ class TapeBlock {
         }
     }
 }
-_a = TapeBlock, _TapeBlock_symbolToPatternListMap = new WeakMap(), _TapeBlock_tapes = new WeakMap(), _TapeBlock_buildPatternList = new WeakMap(), _TapeBlock_getSymbolForPatternList = new WeakMap(), _TapeBlock_symbol = new WeakMap(), _b = symbolToPatternListMapSymbol;
-_TapeBlock_generateSymbolHint = { value: (patternList) => JSON.stringify(patternList
-        .map((pattern) => pattern
-        .map((symbol) => (symbol === ifOtherSymbol ? null : symbol)))) };
+_a = TapeBlock;
 TapeBlock.fromAlphabets = (alphabets) => {
     return new _a({ alphabets });
 };
 TapeBlock.fromTapes = (tapes) => {
     return new _a({ tapes });
 };
+_TapeBlock_generateSymbolHint = { value: (patternList) => JSON.stringify(patternList
+        .map((pattern) => pattern
+        .map((symbol) => (symbol === ifOtherSymbol ? null : symbol)))) };
 export default TapeBlock;

package/dist/classes/TuringMachine.js

@@ -11,6 +11,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _TuringMachine_tapeBlock, _TuringMachine_stack;
 import { haltState } from './State';
+import { lockSymbol } from './TapeBlock';
 import { symbolCommands } from './TapeCommand';
 class TuringMachine {
     constructor({ tapeBlock, } = {}) {
@@ -25,67 +26,75 @@ class TuringMachine {
         return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f");
     }
     run({ initialState, stepsLimit = 1e5, onStep }) {
-        const iterator = this.runStepByStep({ initialState, stepsLimit });
-        for (const machineState of iterator) {
+        const generator = this.runStepByStep({ initialState, stepsLimit });
+        for (const machineState of generator) {
             if (onStep instanceof Function) {
                 onStep(machineState);
             }
         }
     }
     *runStepByStep({ initialState, stepsLimit = 1e5 }) {
-        const stack = __classPrivateFieldGet(this, _TuringMachine_stack, "f");
-        let state = initialState;
-        if (state.overrodeHaltState) {
-            stack.push(state.overrodeHaltState);
-        }
-        let i = 0;
-        while (!state.isHalt) {
-            if (i === stepsLimit) {
-                throw new Error('Long execution');
+        const executionSymbol = Symbol('execution');
+        try {
+            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].check(executionSymbol);
+            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].lock(executionSymbol);
+            const stack = __classPrivateFieldGet(this, _TuringMachine_stack, "f");
+            let state = initialState;
+            if (state.overrodeHaltState) {
+                stack.push(state.overrodeHaltState);
             }
-            i += 1;
-            const symbol = state.getSymbol(__classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f"));
-            const command = state.getCommand(symbol);
-            let nextState = state.getNextState(symbol).ref;
-            try {
-                const nextStateForYield = nextState.isHalt && stack.length
-                    ? stack.slice(-1)[0]
-                    : nextState;
-                yield {
-                    step: i,
-                    state,
-                    currentSymbols: __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").currentSymbols,
-                    nextSymbols: command.tapesCommands.map((tapeCommand, ix) => {
-                        if (typeof tapeCommand.symbol === 'symbol') {
-                            switch (tapeCommand.symbol) {
-                                case symbolCommands.erase:
-                                    return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").tapes[ix].alphabet.blankSymbol;
-                                case symbolCommands.keep:
-                                    return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").tapes[ix].symbol;
-                                default:
-                                    throw new Error('invalid symbol command');
+            let i = 0;
+            while (!state.isHalt) {
+                if (i === stepsLimit) {
+                    throw new Error('Long execution');
+                }
+                i += 1;
+                const symbol = state.getSymbol(__classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f"));
+                const command = state.getCommand(symbol);
+                let nextState = state.getNextState(symbol).ref;
+                try {
+                    const nextStateForYield = nextState.isHalt && stack.length
+                        ? stack.slice(-1)[0]
+                        : nextState;
+                    yield {
+                        step: i,
+                        state,
+                        currentSymbols: __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").currentSymbols,
+                        nextSymbols: command.tapesCommands.map((tapeCommand, ix) => {
+                            if (typeof tapeCommand.symbol === 'symbol') {
+                                switch (tapeCommand.symbol) {
+                                    case symbolCommands.erase:
+                                        return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").tapes[ix].alphabet.blankSymbol;
+                                    case symbolCommands.keep:
+                                        return __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").tapes[ix].symbol;
+                                    default:
+                                        throw new Error('invalid symbol command');
+                                }
                             }
-                        }
-                        return tapeCommand.symbol;
-                    }),
-                    movements: command.tapesCommands.map((tapeCommand) => tapeCommand.movement),
-                    nextState: nextStateForYield,
-                };
-            }
-            catch (error) {
-                if (error === haltState) {
-                    throw new Error(`Execution was stopped because of STOP`);
+                            return tapeCommand.symbol;
+                        }),
+                        movements: command.tapesCommands.map((tapeCommand) => tapeCommand.movement),
+                        nextState: nextStateForYield,
+                    };
+                    __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").applyCommand(command, executionSymbol);
+                    if (nextState.isHalt && stack.length) {
+                        nextState = stack.pop();
+                    }
+                    if (state !== nextState && nextState.overrodeHaltState) {
+                        stack.push(nextState.overrodeHaltState);
+                    }
+                    state = nextState;
+                }
+                catch (error) {
+                    if (error !== haltState) {
+                        throw error;
+                    }
+                    break;
                 }
-                throw error;
-            }
-            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f").applyCommand(command);
-            if (nextState.isHalt && stack.length) {
-                nextState = stack.pop();
-            }
-            if (state !== nextState && nextState.overrodeHaltState) {
-                stack.push(nextState.overrodeHaltState);
             }
-            state = nextState;
+        }
+        finally {
+            __classPrivateFieldGet(this, _TuringMachine_tapeBlock, "f")[lockSymbol].unlock(executionSymbol);
         }
     }
 }

package/dist/utilities/functions.d.ts

@@ -1,4 +1,4 @@
 declare const uniquePredicate: <T>(v: T, i: number, a: T[]) => boolean;
-declare function id(object: Object): number;
+declare function id(object: object): number;
 declare namespace id { }
 export { id, uniquePredicate, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turing-machine-js/machine",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0",
   "description": "A convenient Turing machine",
   "author": "Ruslan Gilmullin <mellonis14@gmain.com>",
   "homepage": "https://github.com/mellonis/turing-machine-js#readme",
@@ -21,5 +21,5 @@
     "machine"
   ],
   "module": "dist/index.js",
-  "gitHead": "2eb49e091614e3c65f95bbd7626943263fb4d1b3"
+  "gitHead": "7ed5b8d294b24bf92c1d26e27b752004fe5055dc"
 }