Dust Programming Language

Dust is a programming language inspired by Rust and targeted to run on browsers and on JavaScript engines. The runtime works by translating Dust code to JavaScript.

The following examples demonstrate the language basics.

The keyword let is used to declare a variable. The type of variable is inferred. In the example, using msg + 1 will result in a compilation error because we are trying to add a number to a string.

Use // to comment a line.

if ... else if ... else blocks need curly braces around the blocks. The brackets around the condition are not required.

if ... else can also act as expression. Eg, let max = if a > b { a } else { b };

Instead of switch, there's match control structure which works by matching a value with a pattern and executing the matching arm. _ has the semantics of otherwise.

Just like if, it can have an expression on the RHS or a block of code. It should be noted that the type checking is in place which means that all the RHS must have the same type.

Again, brackets around the condition are skipped.

The semantics of mut are to indicate if a variable is mutable. However, it is not yet enforced in the language.

Operator ++ is not supported, use += 1.

The last expression is returned. Note that the function defined in the example is not polymorphic. Calling double on a string type will fail. The correct signature for a polymorphic double function is fn double<T>(x: T) -> T

Implementation of KMP algorithm

/// returns minimum index where W is found in S
fn kmp(S, W) {

// build table T
    let mut pos = 2;
    let mut cnd = 0;
    let mut T = [];

let mut j = 0;
    while j < W.length {
        T.push(0);
        j += 1;
    }

T.set(0, -1);
    T.set(1, 0);
    while pos < W.length {
        if W.charCodeAt(pos - 1) == W.charCodeAt(cnd) {
            cnd += 1;
            T.set(pos, cnd);
            pos += 1;
        } else if cnd > 0 {
            cnd = T.get(cnd);
        } else {
            T.set(pos, 0);
            pos += 1;
        }
    }

// start the search
    let mut m = 0;
    let mut i = 0;
    while m + i < S.length {
        if W.charCodeAt(i) == S.charCodeAt(m + i) {
            if i == (W.length - 1) {
                return m;
            }
            i += 1;
        } else {
            if T.get(i) > -1 {
                i = T.get(i);
                m += i - T.get(i);
            } else {
                i = 0;
                m += 1;
            }
        }
    }

S.length
}

alert(kmp("ABC ABCDAB ABCDABCDABDE", "ABCDABD"));

The function kmp implements the Knuth-Morris-Pratt string searching algorithm and is based on the pseudocode provided on the wikipedia entry for the algorithm.

Note that the implementation does not follow a good naming convention and uses JavaScript functions, eg, charCodeAt instead of relying on its standard library (Dust's standard library is missing, it works by transpiling Dust code to JavaScript). There is no [] operator to access array element currently; as a workaround, JavaScript Array prototype has been armed with get and set functions which facilitates the usages like T.get in the example.

Dust → JavaScript

Hello World!

If statement

Match

Loop

Function

Implementation of KMP algorithm