RuntypeScript (aka rts) is a scripting language made in 48h for the fourth langjam hosted at langjam/jam0004. The theme was The sound(ness) of one hand typing.
The language is heavily inspired by TypeScript's type system, so being familiar with it will make it easier to understand this language.
What I've noticed is that there are often two islands, so to speak.
Example residents of the type island:
number
string
boolean
false
true
"foo"
"foo" | "bar"
0
0 | { foo: number[] }These are valid types both in TypeScript and in RuntypeScript.
Example residents of the value island:
false
true
"foo"
"bar"
0
{ foo: [1] }These are valid values both in TypeScript and in RuntypeScript.
Notice how there are some common parts between these two. Some things look
literally the same (like true type, which represents a type with only one
valid value, which happens to be true). In RuntypeScript types and values
are identical, and not just syntatically: they literally are the same thing.
Types are values. Values are types. When the islands merge, they become the same thing and can interact in unprecedented ways. So, merging two previous code snippets gives us this:
number
string
boolean
false
true
"foo"
"bar"
"foo" | "bar"
0
0 | { foo: number[] }
{ foo: [1] }
In RuntypeScript, these expressions can be used both as a type and as a value (because, again, they are the same thing – there's really no distinction between these too). This makes the following snippet a valid RuntypeScript code:
const a = number;
const b = string;
const c = boolean;
const d = false;
const f = true;
const g = "foo";
const h = "bar";
const i = "foo" | "bar";
const j = 0;
const k = 0 | { foo: number[] };
const l = { foo: [1] };
const aa: a = 2; // has to be a number
const bb: b = "baz"; // has to be a string
const cc: c = false; // has to be a boolean
const dd: d = false; // etc.
const ff: f = true;
const gg: g = "foo";
const hh: h = "bar";
const ii: i = "foo"; // could be "bar" as well
const jj: j = 0;
const kk: k = { foo: [1, 2, 3] };
const ll: l = { foo: [1] };
This can lead to many silly ideas, like building objects or union types at runtime (potentially based on user input or randomness) to later use them as types. Check out examples directory for more.
This project is written in TypeScript and targets the Node.js runtime. Run these commands to install dependencies and compile:
npm install
npx tsc --build
After building run node . to see additional flags or node . FILE to read,
compile and execure a script in FILE. These are the commands to run all of the
included examples:
node . ./examples/decltype.rts
node . ./examples/dictionary.rts
node . ./examples/extends.rts
node . ./examples/primes.rts
node . ./examples/signature.rts
node . ./examples/vector.rts
More detailed documentation can be found at the GitHub page for this project.