# Jolf

interpreter
I use marked, along with some code I put together for this page. Enjoy!
# 1. What is prefix language? There are three main types of operator-data placement schemes: Prefix, infix, and postfix. Infix is the one we are all familiar with, in which the operator is placed in between the operands, as in `5 + 7`. Infix is found in, erm, _practical_ programming langauges. Postfix is the scheme in which the operators follow the operands, as in `5 7 +`. Postifx schemes are found in stack-based languages, such as [><>](https://esolangs.org/wiki/Fish) and [Vitsy](https://github.com/VTCAKAVSMoACE/Vitsy). Lastly is prefix, in which the operators precede the operands, as in `+ 5 7`. The following statements are all equivalent in prefix, infix, and postfix respectively: ^ 4 / + 5 9 2 4 ^ ((5 + 9) / 2) 4 5 9 + 2 / ^ Being a prefix langauge, Jolf can easier be thought of as a sort of functional scheme, in which each command represents a function, with its arguments following afterwords. Say you have the JavaScript program `alert(3 + 5)`; then, if you think if `+` as a function `add`, you could re-write that as `alert(add(3,5))`. Since Jolf has a command for both `alert` and `add`, this is rewritten as `a+35`. This is the conversion process: alert(3+5) alert(add(3,5)) alert( + 3 5 ) a + 3 5 a+35 # 2. Commands This is an index of the commands. (One can form a two-byte command by prefixing an instruction with a tilde (`~`).) ## 2.1. Function instructions These instructions are the operators of Jolf. "`typeA, typeB` (&)" means the order does not matter. All ranges are integer ranges, unless they have a specified step. * `*` - multiplies 2 arguments * `number, number` - multiplies the two numbers * `string, number` (&) - repeats `string` `number` times * `array, number` - creates a 2D array of length `number` that contains `array` as all of its members * `+` - adds 2 arguments, according to their types: * `number, number` - adds the two numbers * `anything, string` or `string, anything` - returns `string` concatted with `anything` (preserving order) * `array, array` - concats the two arrays * `non array, array` - Puts `non array` at the beginning of `array` * `array, non array` - pushes `non array` to `array` * `set, set` - the set union of the two sets * `-` - subtracts 2 arguments (behaviour TBA) * `.` - takes 2 arguments `O` and `p` and returns `O[p]` * `/` - takes 2 arguments `A` and `B` and returns `A/B` (behaviour TBA) * `<` - takes 2 arguments `A` and `B` and returns `A < B` (JS behaviour) * `=` - takes 2 arguments `A` and `B` and returns `A == B` * `>` - takes 2 arguments `A` and `B` and returns `A > B` (JS behaviour) * `@` - returns the character code of the next character * `A` - takes 3 arguments `r`, `s`, and `t`; replaces each character in `s` found in `r` with the respective character found in `t` * `B` - takes 1 argument `N` and converts it to binary as a string (equiv. `(N).toString(2)`) * `C` - takes 2 arguments `A` and `B` and parses the string `A` as an integer in base `B` (equiv. `parseInt(A,B)`) * `O` - takes the product of 1 argument, depending on its type: * `array` - takes the product of the array * `P` - takes 1 argument `A` and returns `Number(A)` (converts all to number, if possible) (conversion an array into a number, as in `[1,2,3,1,0,2] => 123102`) * `Q` - squares 1 argument `S`, according to its type: * `number` - multiplies it by itself * `array` - takes the length of the array `N` and returns an array containing `N` copies of itself * `string` - TBA * `T` - takes 2 arguments `F` and `s`; surrounds `F` expression (after compilation) with quotes and evaluates that action `F` every `s` milliseconds * `R` - takes 2 arguments `F` and `s`; runs `F` after `s` milliseconds * `V` - takes 1 argument `S` and is the value `V` of `S`; if `S` is a number, returns `S`'s parity * `^` - takes 2 arguments `A` and `B` and retursn `A^B` (exponentiation) (behaviour TBA) * `_` - negates 1 argument, according to its type: * `string` or `array` or `set` - reverses the entity * `number` - negates the entity * `a` - outputs (alerts/writes) 1 argument * `b` - takes an integer `N` and a base `b` and returns `(N).toString(b)`; when `b = 1`, this is equal to a string of length `N` filled with `#`s. * `c` - writes 1 argument to the log (`console.log` at the moment) * `e` - takes 1 argument `S` and evaluates it as a new Jolf program; returns nothing at the moment * `f` - takes 2 arguments `F` and `R` as a function and takes the array `R` as its commands. * `p` - takes 3 arguments `a`, `b`, and `s` and creates a range `[a,b)` with a step `s` * `r` - takes 2 arguments `a` and `b` and creates a range `[a,b)` (inclusive of `a` and exclusive of `b`) * `u` - takes 1 argument * `array` or `set` - returns the sum of the entity * `string` - behaviour TBA * `number` - takes the digit sum of the number (e.g. `u(140) = 1 + 4 + 0 = 5`) * `v` - takes 2 arguments `S` and `V`; sets the value of variable `S` to `V` and creates `S` if nonexistant (returns `V`) * `z` - takes 1 argument and returns a range `[1,a]` * `~i` - takes 1 argument and returns that argument (the identity function) ## 2.2. Data commands These instructions are the data/arguments of Jolf. ### 2.2.1. As arguments These are written as arguments. * `0-9` - that number * `q` - writes the source code's reference to the the compiled code * `i` and `I` - receive string input from `prompt` * `j` and `J` - receive numeric input from `prompt` * `E` - the empty string `""` * `Y` - the empty array `[]` * `~e` - Euler's number approx `2.718281828459045` * `~p` - π approx `3.141592` * `~P` - ϕ, `(1+sqrt)/2` ### 2.2.2. As writing These are simply written to the compiled code. * `~A` - writes `Array` to the compiled code * `~M` - writes `Math` to the compiled code * `~N` - writes `Number` to the compiled code * `~S` - writes `String` to the compiled code * `~p` - writes `prototype` to the compiled code * `~0` - Infinity * `~s` - writes `Set` to the compiled code * `~N`, for `N in [1,2,3,4]` - `10^(N+1)` ## 2.3. Null-arity commands These instructions do no affect the compiled code _per se_, but provide structure. * `"` - begins string literal; writes characters to compiled code (surrounded by quotes) until another unescaped `"` is met * `'` - character literal; writes next character to compiled code (surrounded by quotes) * `\$` - begin function literal; writes characters to compiled code as is, until another unescaped `\$` is met * `:` - begin character literal; writes the next character to compiled code as is * `[` - begin array parsing (separated by commas) * `GRAVE` - forces an argument check * `\b` (hex 08) - prevents auto output * `x` - quit parsing of expression