Types

Dust is a dynamically typed language. Its primitive types available are the following:

Booleans

A boolean can either be true or false. They support the usual boolean operations:

// logical and
x && y

// logical or
x || y

// logical not
!x

The && and || operators perform short-circuit evaluation. For example, false && f() evaluates to false without evaluating f().

Numbers

⚠️ Dust doesn't parse floating point literals yet

There is not distinction between integers and floating point numbers.

42   // a number
42.1 // still a number

They support the usual arithmetic infix operators:

-x // unary negation
x + y // addition
x * y // multiplication
x - y // subtraction
x / y // division
x % y // modulo

Strings

⚠️ Dust doesn't parse escape characters in strings yet

Strings are created using " characters and are immutable

"hello!"

nil (also called "unit" or "empty tuple" in other languages) is a value that can either be used as a return value for functions that do not return any meaningful values (e.g. print()) or couldn't return any possible values for a certain input. There is only one instance of nil (meaning that nil == nil)

Tuples

Tuples are immutable sequences of data. Currently only 2 and 3 elements tuples are supported. A possible use case is to return multiple values from a function

#(a, b)
#(a, b, c)

Lists

Lists are internally represented as linked lists.

// Empty list
[]

// The cons operation allows to prepend in O(1) time an head to a list, e.g.
[1, ..[2, ..[3, ..[]]]] // => [1, 2, 3]

// But there's also a syntax sugar to do the former
[1, 2, 3]

You can mix those syntaxes as long as the `..` comes last:
[1, 2, ..tl]

Maps

Maps are key-value dictionaries. Only strings are currently supported as keys.

// Empty map
#{ }

// a map with two entries
#{ "x" => 0, "y" => 1 }

let m = #{ "x" => 0 }
// `cons` a map into another
#{ "y" => 1, ..m } // => #{ "x" => 0, "y" => 1 }

// entries can also be computed:
let key = "x";
#{ key => 42 } // => #{ "x" => 42 }

Dust Lang