Dust

High-level programming language with effortless concurrency, automatic memory management and type safety.

Dust is a work in progress. Because it aims to deliver a high level of safety, extensive testing is required. The language is still in the design phase, and the syntax is subject to change.

Usage

The Dust command line tool can be used to run Dust programs. It is not yet available outside of this repository.

cargo run --package dust-shell -- examples/hello_world.ds

cargo run --package dust-shell -- -c '"Hello my name is " + read_line() + "!"'

Dust is easily embedded in another program. You can run a dust program of any size or complexity with a single function.

use dust_lang::{run, Value};

fn main() {
    let code = "
        let x = 'Dust'
        let y = ' is awesome!'

        write_line(x + y)

        42
    ";

    let result = run(code);

    assert_eq!(result, Ok(Some(Value::integer(42))));
}

Concepts

Effortless Concurrency

Dust makes concurrency as effortless as possible. Dust is organized into statements, and any sequence of statements can be run concurrently by simply adding the async keyword before the block of statements.

// Counts from 0 to 9, sleeping for an increasing amount of time between each.
let count_slowly = fn (multiplier: int) {
    i = 0

    while i < 10 {
        sleep(i * multiplier)
        write_line(i.to_string())

        i += 1
    }
}

async {
    count_slowly(200) // Finishes last
    count_slowly(100) // Finishes second
    count_slowly(50)  // Finishes first
}

Automatic Memory Management

Dust uses a garbage collector to automatically manage memory.

let x = 0     // x is assigned but never used
              // x is removed from memory

let y = 41    // y is assigned
let z = y + 1 // y is kept alive for this statement
              // y is removed from memory

write_line(z) // z is kept alive for this statement
              // z is removed from memory

Type Safety

Dust is statically typed and null-free, but the type of a value can usually be inferred from its usage. Dust will refuse to run programs with type errors, but will usually not require type annotations.

// These two statements are identical to Dust
let x = 1
let x: int = 1

// Numbers with decimals are floats
let y = 10.0
let y: float = 10.0

// Strings are enclosed in double quotes and are guaranteed to be valid UTF-8
let z = "Hello, world!"
let z: str = "Hello, world!"

Aside from the ubiqutous bool, int, float, and str types, Dust also has lists, maps, ranges, structures, enums and functions.