Reverse polish notation (RPN) programming language compatible with JavaScript.
titanium-lang is a stack based RPN language. It is an interpreted language. The interpreter runs in JS, and can load and call any JS module.
The code looks the way it does because it is an early prototype :)
- Very simple syntax - titanium programs are simply a list of operands and operators.
- Very little nesting is required, making it ideal for writing one liners!
- Ability to use custom JS modules as operators.
Install the package globally:
npm install -g titanium-lang
After installing the package, you can either write the program in a file or on the command line.
Examples:
t "3 4 + ++ print"
t /in:program.ttn
Simple programs which won't confuse your shell can also be written without putting it in quotes on the command line:
t 3 4 + 70 swap / print
titanium can also be used instead of t on the command line.
Literals
These are the literals which are currently supported:
- numbers (ex,
3.14) - booleans (ex,
true/false) - regexes (ex,
/foo(\d+)/i) - strings
Strings look like the following:
`this is a non verbatim string\r\n`
@`C:\foo\verbatim_string`
Verbatim strings can contain backslashes, but in non-verbatim strings they have a special meaning (just like any other language).
Variables
Variable assignment pops an entry from the stack and assigns it to the variable:
10 3 + =foo
Variables can be put back on the stack like so:
10 3 + =foo !foo !foo / print
The program above outputs 1 (it divides 13 by itself).
If statements and loops
If statements and loops are also stack based! The boolean condition, main body, and the if/ifelse/while operators all go on the stack like so:
(5 3 >) (`foo` print) (`bar` print) ifelse
The program above prints foo if 5 is bigger than 3, bar otherwise.
Else blocks can be skipped like so:
(5 3 >) (`foo` print) if
Currently while loops are the only kind of loops which are implemented, and they look like so:
(5 3 >) (`foo` print) while
(The loop above will obviously loop forever!)
map operator
The map operator is one of the very useful operators in this language. (You can find others by looking at the source).
newarray 3 push 4 push 5 push !print map
The example above constructs an array which looks like this [3,4,5]. Then the print function is placed on the stack, and then the map operator is called. The print function is applied to all elements of the array, and therefore everything in the array is printed to stdout.
Custom lambda functions can be written and used in addition to the built in ones like so:
newarray 3 push 4 push 5 push (dup *) map !print map
The (dup *) lambda function duplicates the top most item on the stack and multiplies it, which ends up squaring the number. So the numbers printed by the program above should be 9, 16, and 25.
Reading files
Files can be read using the readlines operator like the following:
@`C:\foo\file.txt` readlines !print map
Advanced Example
@`C:\test.txt` readlines 100 =id ( /\d+/ !id searchreplace !id ++ =id ) map !print map
The program above takes a files with the lines foo33, foo78, foo1, etc. and outputs foo100, foo101, foo102.
A custom JS module should export an object, whose keys would be used as operator identifiers, and the values would be used as the functions which run when the operator is used. Example module file:
var sqr = function(a) {
return x*x;
}
var pi = function() {
return Math.PI;
}
module.exports = {
sqr: sqr,
pi: pi
};
The module above can be used in a titnaium program like the following:
3 4 + pi + sqr print
The program above adds 3, 4, pi, and squares the end result.
The module, along with the input titanium source can be specified on the command line:
t /modules:C:\modules\mymodules.js /in:mysource.ttn