I can sort of see that @something appears to define it, !something recalls it's value, I assume ? is an if statement of sorts, the rest of the things I just don't see yet but will probably understand when a fuller explanation comes later. Right now the biggest thing I don't see is why the second !test returns a-z instead of z-a again.
So what the ! actually does is "execute" the contents of a variable as instructions. You are correct that ? is a conditional (testing if a variable is empty or not) with the ! immediately following it being a variable whose contents will be executed if the condition fails.
The key function (and in this rather strange language functions and variable values are interchangeable) is this one:
@reverse=?x!final_>x,y_<z,y_!reverse
and one thing you might notice straight away is the !reverse at the end of it which means that if you execute !reverse it will execute itself (as the last step). Noting that if the conditional fails then no further steps are executed (so you don't end up with an infinite loop).
To pull it apart step by step (noting that underbars are the step separators) we have:
?x!final which will check to see if
x is empty and if so then the function
final will be called (and no further step)
>x,y this is a special operation that removes the last character from
x and then prepends it to
y<z,y this is another similar operation that removes the first character from
y and the appends it to
zreverse executes the function again
The other other functions involved are
test (the main entry point),
assign (used to assign an initial value if one doesn't already exist) and
final which stores and outputs the value of
z and then deletes the variables
x,
y and
z.
It is a "string reverse" and that is why if it is repeated the output is the reverse of the previous one.
Being basically just a functional language there are no line numbers so the order that the variables are defined in doesn't matter provided they all exist when you go to execute
test.
