Rym

Rym Lang or just Rym is a modern, statically typed programming language inspired by Rust, Swift, Python and others that focuses on ease of use and safety. Big thanks go to Robert Nystrom who made his book crafting interpreters open source which enabled me to read it and learn a lot :).

Content

• Rym
  • Content
  • About Rym
    • Name
    • Goals
  • Examples
  • How to install
  • Inspirational projects
  • Similar projects
  • Project Structure
    • Tests
• Todos

About Rym

Name

• Rusty ⇒ Heavily borrows 🙃 from Rust
• Multi-paradigm ⇒ Mix of object oriented, procedural and functional programming
• Programming Language ⇒ because thats what it is

Goals

• MVP
  • Safety
    • No null nil undefined
    • Optionals wrapped in Option<T> enum
    • Errors wrapped in Result<T>
    • Statically typed
• 1.0
  • Nice DX (Development Experience)
    • Inferred types
    • Informative errors and warnings
    • Builtin tools
  • Great interoperabilty with Rust
    • Should just work out of the box
• Past 1.0
  • Ui and Apps programming

Examples

func main() -> Result<(), Error>, ?Io {
	const msg = "Hello World"
	print(msg)

	mut num = 2/4 * (10 - 1)
	print("Number:", num)

	const msg = msg + "!"
	print("Combined:", msg, num)
}

In Rym you can unwrap Tryable values like Options or Results

const inner = maybe_value()!

// Same as
const inner = maybe_value().unwrap()

Early returns when unwrapping Tryables

func main() -> Result<Number, String> {
	const number = maybe_error()?
	print(number)

	// Same as
	const inner = match maybe_error() {
		Ok(val) => val,
		err => return err,
	}
	print(inner)
}

Tryable chaining

const chained = maybe_error()&.to_string()

// Short form of:
const chained = match maybe_error() {
	Ok(val) => Ok(val.to_string()),
	err => err,
}
// or:
const chained = maybe_error().and_then(|val| Ok(val.to_string()))

How to install

TODO

Inspirational projects

• HVM: A massively parallel, optimal functional runtime in Rust
• Unison: A friendly programming language from the future (statically-typed, functional)
• Fused Effects: A fast, flexible, fused effect system for Haskell
• Rust: Empowering everyone to build reliable and efficient software.
• Swift: A Swift is a high-performance system programming language.

Similar projects

• Boson: Hybrid programming language written in Rust.
• Mun: Programming language empowering creation through iteration.
• Tao: Statically-typed functional language with polymorphism, typeclasses, algebraic effects, sum types, pattern-matching, first-class functions, currying, good diagnostics, and much more!
• Rhai: Embedded scripting language for Rust.
• Rune: Embeddable dynamic programming language for Rust.

Project Structure

The project is split into many crates that are part of one Cargo workspace:

crates/rym_span ⇒ Span crates/rym_tt ⇒ TokenTree, TokenStream crates/rym_lexer ⇒ Isolated initial lexer

crates/ast ⇒ Ast Types: Spanned, AstVisitor, Token, ... crates/lex ⇒ produce Tokens from source crates/parse ⇒ produce ast from tokens crates/code_gen ⇒ generate optimized code (dead code analysis, ...) or give warnings crates/tree_walk ⇒ evaluate ast crates/tests ⇒ integration tests crates/rymx ⇒ command line tool for executing .rym files

And some other scripts located in the root directory:

bench.sh ⇒ builds and runs various benchmarks test.py ⇒ updates and runs all tests

Tests

Run python test.py to update and execute all tests.

This internally runs cargo r --bin gen -- ./crates/tests/src/integration which includes the source code for all tests into crates/tests/src/integration/mod.rs.

Todos

use insta snapshot testing crate
add benchmarking capabilities
use arena allocator for scopes?
benchmark before & after
use logos lexer generator?
errors
use Spanned<T> where possible
implement error recovery to jump to next safe expr/stmt
use error codes that link to a more detailed explanation (https://github.com/rust-lang/rust/tree/master/compiler/rustc_error_codes)
true && (break) currently only returns Error: Expected Literal got RightParen, Span: 14..14, it should also say something along the lines of: Tip: insert expression or semicolon after break
data types
numbers, string, char, bool
(literal) values that come from source code directly:
Literal<u8>, Literal<f32>, Literal<string>, Literal<char>, Literal<bool>
1, 2.2, "Hello World!", '\n', false
type unions: 0 | 1 | bool
type functions docs/functions.md?