Programming language using PEGjs/peggy

[mikeaustin]

I've worked on many variations of a programming language over the years. Recently, a new variation has solidified and is starting to feel "right", called Kopi. It is...

Simple – 'match' for example, is simply a function, and pattern matching is just an n-tuple of anonymous functions.
Immutable – Shared mutable data is bad, but some impure functions such as 'print' and 'random' are handy.
100% Async – 'input' simply waits for user input and resolves as an argument to 'match'. 'sleep' does the same.

It's kind of a LISP-ish runtime with a Haskell-ish syntax running inside of JavaScript (Node). It's using PEGjs (will likely convert to peggy), and can be found here: https://github.com/mikeaustin/kopi. It's still in the experiment phase, so no prod use, yet :)

[hildjj]

I'd like to add a section to the website with known uses of Peggy/PegJS. Let's turn this issue into the one tracking that, then add kopi to the list when it exists.

[mikeaustin]

Kopi runs in Node, but now it also works in a browser, with some examples and live compiling:

https://mike-austin.com/kopi

[mikeaustin]

While working on Kopi, I like to have a very basic, trimmed down implementation for reference. I modified the Arithmetics Grammar example to first create an AST, then interpret it. I think it gives a nice, minimal example of a full interpreter, using left-associative and right-associative operators, and naming rules common to many languages (PrimaryExpression, NumericLiteral, etc.). It can be copied and pasted into the online PEG editor.

// Simple Arithmetics Interpreter
// ==============================
//
// Parses syntax into an AST, then interprets the AST directly.
// Accepts expressions such as "2 * (3 + 4)" and computes their value.

{
  function visit(node) {
    return visitors[node.type](node);
  }

  const operators = {
    ['+']: (left, right) => visit(left) + visit(right),
    ['*']: (left, right) => visit(left) * visit(right),
    ['^']: (left, right) => visit(left) ** visit(right),
  }

  const visitors = {
    OperatorExpression: ({ op, left, right }) => {
      return operators[op](left, right);
    },

    NumericLiteral: ({ value }) => {
      return value;
    },
  }
}

Program  // First rule that is run. In this case, interpret program.
  = expr:Expression {
      return visit(expr);
    }

Expression  // Alias so we can add lower precedence operations
  = AddExpression

AddExpression  // Left-associative using looping (* operator)
  = head:MultiplyExpression tail:(_ ("+" / "-") _ MultiplyExpression)* {
      return tail.reduce((left, [, op, , right]) => ({
        type: "OperatorExpression", op, left, right
      }), head);
    }

MultiplyExpression  // Higher precedence than AddExpression
  = head:ExponentExpression tail:(_ ("*" / "/") _ ExponentExpression)* {
      return tail.reduce((left, [, op, , right]) => ({
        type: "OperatorExpression", op, left, right
      }), head);
    }

ExponentExpression  // Right-associative using recursion (self-reference)
  = left:PrimaryExpression "^" right:ExponentExpression {
      return ({ type: "OperatorExpression", op: "^", left, right });
    }
    / PrimaryExpression

PrimaryExpression
  = "(" _ expr:Expression _ ")" { return expr; }
  / NumericLiteral

NumericLiteral "integer"
  = _ [0-9]+ {
      return ({
        type: "NumericLiteral", value: Number(text())
      });
    }

_ "whitespace"
  = [ \t]*