The History of ArachnoScript

ArachnoScript was initially intended to be "another" frontend UI library similar to React but without all the 'horror' as I may have called it. The library was to be called Verdex (Virtual DOM EXtension), but somehow I spelled it with an 'e' instead of 'i' (Virdex). Later on I wanted to make it a full-fledged language as building a UI library like React was impossible (to understand).

As I went deeper into language design, I forgot about the UI library. Soon I decided to rename the language; that was when ArachnoScript was born. My reason for the name will remain untold until some time in the future, when I resume this other project that I abandoned, 'WebOS'.

ArachnoScript shares a lot of similarities with JavaScript primarily because JS is my favorite language, and also so as to maintain familiarity for web developers trying to build a web app with the UI library Verdex. There are many similarities and differences.

ArachnoScript was built from scratch with its own parser and runtime. v0.1 and v0.2 are interpreted releases and, based on benchmarks I ran, AS is currently much slower than JS. v0.3 will include a VM (Virtual Machine) for AS. The VM will significantly improve speed as its compiler will do optimizations and there will be less overhead at runtime.

ArachnoScript Features

• ArachnoScript is focused mainly on backend development.
• It currently has an experimental UI library for web apps as of v0.1. v0.2 promises a more stable and feature rich UI library.
• It currently supports async / await. v0.2 promises service workers and coroutines.
• ArachnoScript supports many of JavaScript's syntax with a touch of its own.
• ArachnoScript has about 13 data types.
• ArachnoScript supports JavaScript's single line comments and its own doc comments that start with '$' and end at the end of the line or with another dollar sign.
• v0.2 offers a more powerful standard library for AS with better error messages.
• AS's built-in functions are called 'macros' and the standard library includes many macros (macros are regarded as unsafe).
• AS does not allow prototype modification.
• Arrays, classes, instances, and objects are different data types in AS.
• In v0.1 the `private` and `public` keywords were no-ops and had no effect on class members; v0.2 will deliver concrete member accessibility.
• AS fully supports inheritance and aims for cross-platform compatibility.
• v0.1 ships with a weak and experimental REPL. v0.2 might not include a REPL; if it does, it will be low priority.

ArachnoScript Syntax

Variable Declarations:

Mutable variables are declared with the 'spawn' keyword.

spawn name = "ECMA King";

Constants are declared with 'immortal' in front.

immortal spawn name = "ECMA King";

Mutable and local-scoped variables:

var a = 0;

Control Flow:

// if-else block

if (true) {}

else if (false) {}

else true;

// switch cases

switch (true) {
  case true: break;
  default:
}

// match expressions

match (100) {
  100 => true,
}

Loops:

// traditional for loop
for (i = 0; i < 10; i++) {}

// while loops
while (true) { break; }
do { break; } while (true);

// for..in loops
for (immortal spawn key in object) {}

// for..of loops
for (immortal spawn value of object) {}

It's all the same for function statements, function expressions, and arrow functions.

Comments:

// line comment
// $ doc comment $ ends with another dollar sign or at end of line

globalThis:

globalThis is a keyword used in member expressions to access variables and other declarations at the top level of the current script.

var obj={}; globalThis.obj; // {}
globalThis.obj=0; obj; // 0
globalThis.abc; // undefined
var abc=123; globalThis.abc; // 123

Type system

AS is dynamically typed like JavaScript. Soon AS will get its own compile-time type system allowing for optional static typing.

Macros

// arrays created with the literal syntax are not objects
var array=[1, 2, 4]; // returns the length of an AS array: #_array_length(array); // 3

// a simple print function that prints strings and only strings
function print(string) {
  // if the value passed is not a string or is not convertable to a byte array, this macro will throw an error
  spawn byte_array=#_new_byte_array(string);
  // Macros are usually built-in functions; there are built-in variables like #_os_stdout
  // #_file_write writes the data of its 2nd argument to the file passed as its 1st argument
  #_file_write(#_os_stdout, byte_array)
}
// As of v0.2, escapes work!
print("Hello World! from \x1b[1;97mAS\x1b[0m\r\n")

// a #_new_byte_array returns a value of type raw [byte array]
spawn byte_array = #_new_byte_array()
// AS operators and keywords cannot carry operations on raw values; only macros can.