Alight

Alight is a two-dimensional esoteric programming language by Abraham Karplus, distinguished from countless others by not using single character commands. In fact, the commands for Alight look somewhat like those for a non-esoteric imperative programming language.

Control Flow
Commands are separated by the semicolon character, " ".The program begins at the command, which may (like any command) be written forwards, backwards, up, or down. It continues in that direction through other commands, some of which may make it change direction. Any direction changes are done as if the semicolon at the ends of the command were the command. The program continue until it reaches the command  in the direction it is going (encountering, say,   will not).

Commands
Whitespace is allowed in a command where it does not split an identifier.

A semicolon followed immediately by another is a nop command, useful for spacing. var x Create a new variable called, initialized to. Variable names must be alphanumeric (any length), and not reserved words. set x Set  to the result of. Enhanced assignment is not supported; use  instead. skip If  is true, skips the next command. turn If  is true, turns a quarter turn left, otherwise turns a quarter turn right. inp x Read a character from input into. out x Output  as a character. wait Waits for seconds, which need not be an integer.

Types
There are three data types in Alight: numbers, lists, and special values. Characters are represented as numbers and strings as lists of characters. Lists may contain either numbers or other lists (but not both). Lists are created with the syntax [, , ] and may contain zero or more items. The syntax 'c represents the number 99, the ASCII value of that character. The syntax "str" creates a list of characters ['s, 't, 'r]. It is legal to use the semicolon character within a string. Lists are indexed beginning at 0.5 (Any index that is not precisely 0.5+k for nonnegative integer k is an error).

Constants
There are currently four special values in Alight nil eof left right They represent an absence of data, the end of file, boolean true, and boolean false, respectively. New variables initially contain. Lists of numbers or lists may contain these values.

Operations
All operators are postfix, so grouping symbols are not required. All operations except the unary logical not are binary.

Arithmetic
The standard arithmetic operations, + - * / are used. Additionally, the  builtin function returns the truncation of a number, and   returns the sign of a number. The plus and times operators may be used for list concatenation and repetition, respectively.

Comparison
The operators for comparison are = < > representing equality, less-than, and greater-than, respectively. Other comparisons may be created by chaining these with the logic operators. These can compare any values (not just numbers), though less-than and greater-than will always return false on other types, and objects of different types return false on comparison.

Logic
The logic operators are ! & | ^ representing not, and, or, and exclusive or, respectively. Bitwise operators are not supported.

List Functions
The function  takes a list, a index number, and optionally a value. If called with two arguments, it returns the value of the list at that point (or if the list is too short). If called with three, it return a copy of the list with that point set to the value (raising an error if the value is the wrong type of the list is too short). The function  takes a list and optionally a positive integer. If called with one argument, it returns the length of the list. If called with two, it appends the specified number of  values to the end of the list, returning the new list.

Calling Functions
Any function may be called with the syntax {, , ...}

Defining Functions
A function is defined in much the same manner as a program, except that the keyword  is replaced with , and   and   have a slightly different syntax: func {, , ...} Defines the function with a given name and arguments (variable names). end Returns from the function as the given value. If unspecified,  is returned.

Namespaces
All functions names are in a separate global namespace. Each function gets its own variable namespace when called and cannot access any other.

Evil Hack
There is nothing preventing the code for a function from merging with the main code or that of another function. When this happens, the function continues as always in its own namespace until it reaches some  command, at which point control returns to wherever it was in the code.

Cat
Using

d                              n                               e begin;var c;inp c;turn c = eof; t                 t            h                  u            g                  r            i                  n            r                                                  r            n                  i            r                  g            u                  h            t                  t            ;thgir nrut;;;c tuo;

Using

begin;var c;inp c;skip c = eof;turn right;end t                            t            h                             u            g                             r            i                             n            r                                                                        r            n                             i            r                             g            u                             h            t                             t            ;thgir nrut;;;;;;;;;;;;;;c tuo;

Reversed Cat
begin;var c;var l;set l [];inp c;;;;;;;;;;;;;;;;;;;skip c = eof;turn right;var x;set x len{l}-0.5;;;;;;;;;;;skip sign{x} > 0;end;turn right; t                                              t                      t                                         t                           h                                               u                      h                                         u                           g                                               r                      g                                         r                           i                                               n                      i                                         n                           r                                                                      r                                                                                                                     r                                                                r                           n                                               i                      n                                         i                           r                                               g                      r                                         g                           u                                               h                      u                                         h                           t                                               t                      t                                         t                           ;thgir nrut;}c ,5.0-}l{nel ,l{ta;}1 ,l{nel l tes;                      ;thgir nrut;1-x x tes;c tuo;}x ,l{ta c tes;