Add a human friendly grammar.

Author: hzhangxyz

g4/Ds.g4

@@ -0,0 +1,43 @@
+grammar Ds;
+
+rule_pool
+    : NEWLINE* rule (NEWLINE+ rule)* NEWLINE* EOF
+    ;
+
+rule
+    : term
+    | (term (',' term)*)? '->' term
+    ;
+
+term
+    : SYMBOL                                                 # symbol
+    | term '(' (term (',' term)*)? ')'                       # function
+    | '(' term ')'                                           # parentheses
+    | <assoc=right> ('~' | '!' | '-' | '+' | '&' | '*') term # unary
+    | term ('*' | '/' | '%') term                            # binary
+    | term ('+' | '-') term                                  # binary
+    | term ('<<' | '>>') term                                # binary
+    | term ('<' | '>' | '<=' | '>=') term                    # binary
+    | term ('==' | '!=') term                                # binary
+    | term '&' term                                          # binary
+    | term '^' term                                          # binary
+    | term '|' term                                          # binary
+    | term '&&' term                                         # binary
+    | term '||' term                                         # binary
+    ;
+
+WHITESPACE
+    : [ \t]+ -> skip
+    ;
+
+COMMENT
+    : '//' ~[\r\n]* -> skip
+    ;
+
+NEWLINE
+    : [\r\n]
+    ;
+
+SYMBOL
+    : ~[ \t\r\n,()]+
+    ;

g4/main.js

@@ -0,0 +1,63 @@
+import antlr4 from "antlr4";
+import DsLexer from "./DsLexer.js";
+import DsParser from "./DsParser.js";
+import DsVisitor from "./DsVisitor.js";
+
+class Visitor extends DsVisitor {
+  visitRule_pool(ctx) {
+    return ctx.rule_().map(r => this.visit(r)).join("\n\n");
+  }
+
+  visitRule(ctx) {
+    const result = ctx.term().map(t => this.visit(t));
+    if (result.length === 1) {
+      return result[0];
+    } else {
+      const conclusion = result.pop();
+      const length = Math.max(...result.map(premise => premise.length));
+      result.push("-".repeat(length));
+      result.push(conclusion);
+      return result.join("\n");
+    }
+  }
+
+  visitSymbol(ctx) {
+    return ctx.SYMBOL().getText();
+  }
+
+  visitFunction(ctx) {
+    return `(function ${ctx.term().map(t => this.visit(t)).join(" ")})`;
+  }
+
+  visitParentheses(ctx) {
+    return this.visit(ctx.term());
+  }
+
+  visitUnary(ctx) {
+    return `(unary ${ctx.getChild(0).getText()} ${this.visit(ctx.term())})`;
+  }
+
+  visitBinary(ctx) {
+    return `(binary ${ctx.getChild(1).getText()} ${this.visit(ctx.term(0))} ${this.visit(ctx.term(1))})`;
+  }
+}
+
+function parse(input) {
+  const chars = new antlr4.InputStream(input);
+  const lexer = new DsLexer(chars);
+  const tokens = new antlr4.CommonTokenStream(lexer);
+  const parser = new DsParser(tokens);
+  const tree = parser.rule_pool();
+  const visitor = new Visitor();
+  return visitor.visit(tree);
+}
+
+// 示例
+console.log(
+  parse(`
+(1 + 2) * a -> - 3
+f(x)
+f(x) == 'x
+`)
+);
+

g4/main.py

@@ -0,0 +1,54 @@
+from antlr4 import InputStream, CommonTokenStream
+from DsLexer import DsLexer
+from DsParser import DsParser
+from DsVisitor import DsVisitor
+
+
+class Visitor(DsVisitor):
+    def visitRule_pool(self, ctx: DsParser.Rule_poolContext):
+        return "\n\n".join([self.visit(r) for r in ctx.rule_()])
+
+    def visitRule(self, ctx: DsParser.RuleContext):
+        result = [self.visit(t) for t in ctx.term()]
+        if len(result) == 1:
+            return result[0]
+        else:
+            conclusion = result.pop()
+            length = max(len(premise) for premise in result)
+            result.append("-" * length)
+            result.append(conclusion)
+            return "\n".join(result)
+
+    def visitSymbol(self, ctx: DsParser.SymbolContext):
+        return ctx.SYMBOL().getText()
+
+    def visitFunction(self, ctx: DsParser.FunctionContext):
+        return f"(function {' '.join(self.visit(t) for t in ctx.term())})"
+
+    def visitParentheses(self, ctx: DsParser.ParenthesesContext):
+        return self.visit(ctx.term())
+
+    def visitUnary(self, ctx: DsParser.UnaryContext):
+        return f"(unary {ctx.getChild(0).getText()} {self.visit(ctx.term())})"
+
+    def visitBinary(self, ctx: DsParser.BinaryContext):
+        return f"(binary {ctx.getChild(1).getText()} {self.visit(ctx.term(0))} {self.visit(ctx.term(1))})"
+
+
+def parse(string):
+    input_stream = InputStream(string)
+    lexer = DsLexer(input_stream)
+    stream = CommonTokenStream(lexer)
+    parser = DsParser(stream)
+    tree = parser.rule_pool()
+    visitor = Visitor()
+    return visitor.visit(tree)
+
+
+print(
+    parse("""
+(1 + 2) * a -> - 3
+f(x)
+f(x) == 'x
+""")
+)