vcfxb/wright-lang

The wright programming language (WIP)

The Wright Programming Language

A language that flies

Wright is an all-purpose programming language inspired by Rust, Ada, and Typescript. Pulling from all three of these excellent languages, Wright intends to offer a combination of speed, ergonomics, and precision.

Badges

Wright is automatically checked and tested using the latest available github runners for Ubuntu, MacOS, and Windows

Service	Badge
Cargo Check Status
Cargo Test Status
Cargo Clippy Status
Code Coverage (Coveralls)
Code Coverage (Codecov.io)
Docs.rs
Crates.io
GitHub release
GitHub (pre-)release
Development Status

	Downloads
Total
Releases
Pre-Releases
Crates.io
Crates.io (Latest)

Syntax Samples

// Hello World! 
use wright::io::println;

func main() {
    println("Hello World!");
}

// FizzBuzz 1 through 100
use wright::io::println;

type FizzBuzzInteger = integer constrain |i| { i <= 100 && i >= 0 };

func fizzbuzz(i: FizzBuzzInteger) {
    if i % 15 == 0 { println("FizzBuzz"); }
    else if i % 5 == 0 { println("Buzz"); }
    else if i % 3 == 0 { println("Fizz"); }
    else { println(i); }
}

func main() {
    // Compiler error here if we use a range iterator that contains a value violating the constraints of 
    // `FizzBuzzInteger`. 
    (1..=100).for_each(fizzbuzz);
}

The core goals of the language:

• Developer experience -- Every error message, syntax choice, and standard library function should be friendly and well documented.
• Robustness -- Wright's type system should be expressive enough to appropriately capture the domain, representation, and functionality of every symbol the programmer interacts with.
• Speed -- Wright leverages the newest major version of LLVM (at the time of writing, LLVM 18), to compile code directly to assembly, avoiding the overhead of an interpreter, garbage collector, and other associated tools by default.
• Memory Safety -- Wright pulls significant inspiration from Rust's lifetime system, with some modifications.

Installation:

There are several installation options.

• Get the latest stable version from the releases page.
• If you have rust, via cargo install wright.
• Building from source, by cloning this repository, and running cargo build --release in the wright directory, and then adding wright/target/release to your system path. You will need LLVM 18 installed and appropriately configured to compile Wright. See the llvm-sys crate docs for tips on how to do this.

wright-lang's Issues

Statements

see https://doc.rust-lang.org/stable/reference/statements.html for a bit of reference

The Semicolon Operator and Expression Categories

Currently, the semicolon ; (used to sequence expressions) is a binary operator. However, in some cases, treating ; this way results in weird-looking code. For example,

func(1, 2; 3, 4)

would be equivalent to

func(1, 3, 4)

As well, this creates ambiguity with the hypothetical variable declaration

"let" Identifier "=" Expression

If Expression is a semicolon-expression.

let x = 5; 3
(let x = 5); 3
let x = (5; 3)

Some of the weirdness could be solved by having different categories of expressions for each of these cases, e.g. NonSemicolonExpression, ExpressionOrVariableDecl.

Union Definition Parse

`self` expression

Tracking issue for adding the self expression to wright

Block Parser

Block ::= "{" [[Expression [";"]] "}"

Notes:

• Blocks do not need an expression list because the semicolon ; is a binary operator.
• The unit value (of the type void) might be expressed as {}.

Treating blocks as expressions that return the value of Expression poses a parsing question: should blocks be valid anywhere an expression is? Examples include

3 + { "hello"; 4 }
func(3, { 2; 1 })

In this case, if ; keeps being an operator, blocks have the same grouping properties as parentheses ().

3 + ("hello"; 4)
func(3, (2; 1))

Should parenthesized expressions also be considered blocks by the grammar?

Match Expression Parser

Enum Definition Parser

Stack_VM Implementation

An implementation of a backend through the Stack VM crate

Trait Definition Parser

Function Definition Parser

Parser and Grammar Modules

Finishing the grammar in the the RustPEG file, and writing the parser and parser error structs

Switch from CodeMap to CodeSpan crate

see the crate page for more info

We are switching to codespan over codemap because it is simply more up to date compared to Rust's libsyntax.

The goal (of course) is to convert all the way to using Rust's libsyntax directly. (however that's not currently possible as it is a nightly-only API right now)

AstEq trait

Tracking issue for AstEq trait that compares AST nodes but ignores fragments.

Function Call Expression

This is the tracking issue for the function call expression (func(args))

If let expression parser

Wright Expression Precedence

Here is a list of applicable Wright expressions with in suggested precedence order.

{
  a::b; // scope resolution
  a.b; // member access
  a..b; // half open range
  a * b / c % d // multiplication/division/remainder
  a + b - c; // addition/subtraction
  a & b; // bitwise and
  a ^ b; // bitwise/logical xor
  a | b; // bitwise or
  a && b; // logical and
  a || b; // logical or
  a < b > c <= d >= e; // comparison
  a == b != c; // equality
  a = b; // assign
  let a = b; // variable creation and jump expressions (e.g. return)
}

This order follows the precedence order in C-like languages, with the additions of variable creation and jump expressions binding at the lowest precedence.

Expressions like { a } and if a { b } else { c } don't need precedence because they do not expose a bare expression at the head or the tail.

Conditional Expression parser

Conditional expression parser tracking issue.

Syntax should be along the lines of

"if", expr, block, ("else", "if", expr, block)*, ["else", block] 

Targets

This is pretty far in the future, but I'll leave some platforms I'm considering targeting here, to look back at for reference later:

• C
• JVM
• LLVM
• Cretonne (If it still exists.)
• Rust (maybe?)
• MIPS (or some subset)
• Brainfuck (maybe?)
• WASM (maybe?)

Interpreter Module

Finishing up the interpreter module and writing unit tests.

Class Definition Parser

Type Definition Parser

Pattern Matching Grammar Stuff

https://doc.rust-lang.org/reference/patterns.html

Impl Block Parser

Struct Definition Parser

Declassify underscore as an expression

Should the underscore really be an expression?

Error module

Finishing up the error module and writing unit tests.

Binary Expression Parser Test Cases

Need to make test cases for all binary operators

Multiline comments

Once #18 is merged we will need to add on to and modify it to also work for multiline comments. This is the tracking issue for that.

Scoped Name/Identifier

ScopedName ::= (Identifier "::")+ Identifier

WebAssembly

Does the compiler run on WebAssembly (wasm)? Is such feature planned?

Replace `# Comment` style with `// Comment` style.

Type System

Tracking issue for the wright type system and type parsers

Binary expression parser

tracking issue for #8

JVM Implementation

Implementing a Java Virtual Machine in rust to target with wright