The Asteria Programming Language

CI	Category	Host OS	Build Status	Remarks
Cirrus CI	🥇Primary	Linux (Ubuntu)
AppVeyor	🥈Secondary	Windows (MSYS2)		Standard I/O not in UTF-32.

Concepts

I started learning programming from ActionScript since Flash 5 days. It was no sooner (and not strange, either) than I learned JavaScript, because they are so similar. I admit that JavaScript is a fascinating language, but it also has quite a few drawbacks when we look at it today:

1. There is no 64-bit integer type. While some data exchange formats (such as Protocol Buffers) do have 64-bit integers, they cannot be stored as Numbers safely. Some implementations split 64-bit integers into higher and lower parts, which is not very handy, as the lower part suddenly becomes signed and may be negative.
2. There are no binary strings. Strings are in UCS-2 (rather than UTF-16), while ArrayBuffers are not resizable.
3. NaN and Infinity are neither keywords nor constants. They are properties of the global object and may be overwritten. Moreover, Boolean(NaN) yields false unlike other languages.

Here is an issue that is shared by almost all common languages, including C and Python:

let a = [ ];
let b = [ ];

function test(x, y) {
  x.length = 0, x[0] = "hello";  // modifies the array that `x` would reference
  y = [ "hello" ];               // modifies `y` instead of the argument
}
test(a, b);  // arguments are in effect pointers

console.log("a = ", a);   // [ 'hello' ]
console.log("b = ", b);   // []

However, compared with typed languages such as Java, JavaScript has a few advantages:

1. A number is always a Number. There are no integer types of varieties of widths, which simplifies programming. Unlike integers, Numbers never overflow.
2. Being untyped, a function can be passed around like objects without knowing its parameters.

Asteria has been highly inspired by JavaScript but has been designed to address such issues.

Features

1. Sane and clean.
2. Self-consistent.
3. Simple to use.
4. Lightweight.
5. Procedural.
6. Dynamically typed.
7. Easy to integrate in a C++ project. (C++17 hexadecimal floating-point literals are required.)
8. Native to C++ exceptions, particularly std::bad_alloc.

Characteristics

1. First-class functions.
2. Closure functions.
3. Exceptions.
4. Flexible syntax similar to C++ and JavaScript.
5. Regular grammar.
6. Argument passing (by value or reference) determined by the argument rather than the parameter.
7. Idempotently copyable values basing on copy-on-write.
8. Minimal garbage collection support.
9. Structured binding similar to C++17.

Data Types

Asteria is untyped. Variables do not have types. Only values (which can be stored in in variables) do. In this sense functions are considered opaque data.

There are 9 data types:

Expression Categories

var foo;
// `foo` refers to a "variable" holding `null`.

const inc = 42;
// `inc` refers to an "immutable variable" holding an `integer` of `42`.

var bar = func() { return ->inc;  };      // return by reference
// `bar` refers to an "immutable variable" holding a function.
// `bar()` refers to the same "variable" as `inc`.

func add(x) { return x + inc;  };   // return by value
// `add` refers to an "immutable variable" holding a function.
// `add(5)` refers to a "temporary" holding an `integer` of `47`.

How to Build

$ autoreconf -i  # requires autoconf, automake and libtool
$ ./configure
$ make -j$(nproc)

The REPL

$ ./bin/asteria

WIP

License

BSD 3-Clause License