Working on mol-script

src/mol-script/script/mol-script/compile.ts

@@ -0,0 +1 @@
+// TODO: compilation step from lisp AST

src/mol-script/parsers/mol-script/parser.ts → src/mol-script/script/mol-script/parser.ts

@@ -5,34 +5,36 @@
  * @author David Sehnal <david.sehnal@gmail.com>
  */
 
+// TODO: add "lisp AST" which is then compiled to mol-script
+
 import { MonadicParser as P } from 'mol-util/monadic-parser'
 
 import Parser from '../parser'
 import Expression from '../../expression'
-import { SymbolMap, MolScriptSymbol } from './symbols'
+// import { MolScriptSymbol } from './symbols'
 import B from '../../builder'
 
 const ws = P.regexp(/[\n\r\s]*/)
 
-function getSymbolExpression(s: MolScriptSymbol, args?: any) {
-    switch (s.kind) {
-        case 'alias': return args ? Expression.Apply(s.symbol.id, args) : Expression.Apply(s.symbol.id);
-        case 'macro': return s.translate(args);
-    }
-}
+// function getSymbolExpression(s: MolScriptSymbol, args?: any) {
+//     switch (s.kind) {
+//         case 'alias': return args ? Expression.Apply(s.symbol.id, args) : Expression.Apply(s.symbol.id);
+//         case 'macro': return s.translate(args);
+//     }
+// }
 
 namespace Language {
-    const Expr = P.lazy(() => P.seq(Symb, ArgList, NamedArgList));
+    const Expr = P.lazy(() => P.seq(Identifier, ArgList, NamedArgList));
 
     const Arg: P<Expression> = P.lazy(() => P.seq(
-        P.lookahead(P.regexp(/[^:]/)),
+        P.lookahead(P.test(ch => ch !== ':')),
         P.alt(
             // order matters
             AtomName,
             ElementSymbol,
             Bool,
             Num,
-            Str,
+            Identifier,
             QuotedStr,
             ListSymbol,
             SetSymbol,
@@ -51,25 +53,11 @@ namespace Language {
         return namedArgs
     });
 
-    const Symb = P.regexp(/[^\s'`,@()\[\]{}';:]+/)  // /[a-zA-Z_-][a-zA-Z0-9_.-]+/)
-        .map(x => {
-            const s = SymbolMap[x];
-            if (!s) {
-                throw new Error(`'${x}': unknown symbol.`);
-            }
-            return s;
-        })
-        .desc('symbol');
-
-    const Str = P.regexp(/[a-zA-Z_-]+[a-zA-Z0-9_.-]*/).map(x => {
-        const s = SymbolMap[x];
-        if (s) return getSymbolExpression(s);
-        return x;
-    }).desc('string');
+    const Identifier = P.regexp(/[^\s'`,@()\[\]{}';:]+/)
+        //.map(id => Expression.Apply(B.core.type.identifier.id, void 0))
+        .desc('identifier')
 
-    const QuotedStr = P.string('`')
-        .then(P.regexp(/[^`]*/))
-        .skip(P.string('`'))
+    const QuotedStr = P.regexp(/[^`]*/).trim(P.string('`'))
         .desc('quoted-string');
 
     const Num = P.regexp(/-?(0|[1-9][0-9]*)([.][0-9]+)?([eE][+-]?[0-9]+)?/)
@@ -101,26 +89,28 @@ namespace Language {
 
     // '.e' => struct.type.atomName(e)
     const AtomName = P.string('.')
-        .then(P.alt(Str, QuotedStr, Num))
+        .then(P.alt(Identifier, QuotedStr, Num))
         .map(v => B.atomName('' + v))
         .desc('identifier');
 
     const List = Expr
         .wrap(P.string('('), P.string(')'))
         .map(x => {
-            const array: any[] = x[1];
-            const named: any = x[2];
-
-            if (named && Object.keys(named).length) {
-                if (array) {
-                    for (let i = 0; i < array.length; i++) named[i] = array[i];
-                }
-                return getSymbolExpression(x[0], named);
-            } else if (array && array.length) {
-                return getSymbolExpression(x[0], x[1]);
-            } else {
-                return getSymbolExpression(x[0])
-            }
+            // const array: any[] = x[1];
+            // const named: any = x[2];
+
+            return 0 as any;
+
+            // if (named && Object.keys(named).length) {
+            //     if (array) {
+            //         for (let i = 0; i < array.length; i++) named[i] = array[i];
+            //     }
+            //     return getSymbolExpression(x[0], named);
+            // } else if (array && array.length) {
+            //     return getSymbolExpression(x[0], x[1]);
+            // } else {
+            //     return getSymbolExpression(x[0])
+            // }
         })
         .desc('list');
 

src/mol-script/type.ts

@@ -13,7 +13,6 @@ namespace Type {
     export interface Variable<T> { kind: 'variable', name: string, type: Type, isConstraint: boolean, '@type': any }
     export interface AnyValue { kind: 'any-value', '@type': any }
     export interface Value<T> { kind: 'value', namespace: string, name: string, parent?: Value<any>, '@type': T }
-    export interface Identifier { kind: 'identifier', '@type': string }
     export interface Container<T> { kind: 'container', namespace: string, name: string, alias?: string, child: Type, '@type': T }
     export interface Union<T> { kind: 'union', types: Type[], '@type': T }
     export interface OneOf<T> { kind: 'oneof', type: Value<T>, namespace: string, name: string, values: { [v: string]: boolean | undefined }, '@type': T }

src/mol-util/monadic-parser.ts

@@ -299,14 +299,15 @@ export namespace MonadicParser {
 
     export function string(str: string) {
         const expected = `'${str}'`;
+        if (str.length === 1) {
+            const code = str.charCodeAt(0);
+            return new MonadicParser((input, i) => input.charCodeAt(i) === code ? makeSuccess(i + 1, str) : makeFailure(i, expected));
+        }
+
         return new MonadicParser((input, i) => {
             const j = i + str.length;
-            const head = input.slice(i, j);
-            if (head === str) {
-                return makeSuccess(j, head);
-            } else {
-                return makeFailure(i, expected);
-            }
+            if (input.slice(i, j) === str) return makeSuccess(j, str);
+            else return makeFailure(i, expected);
         });
     }
 
@@ -472,7 +473,6 @@ function seqPick(idx: number, ...parsers: MonadicParser<any>[]): MonadicParser<a
     });
 }
 
-
 function makeSuccess<T>(index: number, value: T): MonadicParser.Success<T> {
     return { status: true, index, value };
 }
@@ -515,20 +515,11 @@ function formatGot(input: string, error: MonadicParser.ParseFailure) {
     }
     const prefix = i > 0 ? '\'...' : '\'';
     const suffix = input.length - i > 12 ? '...\'' : '\'';
-    return (
-        ' at line ' +
-        index.line +
-        ' column ' +
-        index.column +
-        ', got ' +
-        prefix +
-        input.slice(i, i + 12) +
-        suffix
-    );
+    return ` at line ${index.line} column ${index.column}, got ${prefix}${input.slice(i, i + 12)}${suffix}`;
 }
 
 function formatError(input: string, error: MonadicParser.ParseFailure) {
-    return 'expected ' + formatExpected(error.expected) + formatGot(input, error);
+    return `expected ${formatExpected(error.expected)}${formatGot(input, error)}`;
 }
 
 function unsafeUnion(xs: string[], ys: string[]) {

src/perf-tests/mol-script.ts

@@ -1,5 +1,5 @@
-import Examples from 'mol-script/parsers/mol-script/examples'
-import transpile from 'mol-script/parsers/mol-script/parser'
+import Examples from 'mol-script/script/mol-script/examples'
+import parse from 'mol-script/script/mol-script/parser'
 
-const expr = transpile(Examples[Examples.length - 1].value);
+const expr = parse(Examples[Examples.length - 1].value);
 console.log(expr);