InterWater

InterWater is something like a combination of Unlambda and Hargfak. The syntax is different inside and outside of a code-block.

Inside of a code-block
It works like Hargfak, with all of those commands except =~|`'% and the preprocessor works like in Hargfak, except that macros are not defined inside of a code-block (they still may be called from inside of a code-block). There is also a new data type, a function (which acts similarly to a code-block, and a function code-block is a code-block).

This is how a function data-type acts:
 * +- The function does not change.
 * [] Treated as zero (unless it is a non-empty code-block).
 * . Applies the function to the memory-state (the memory-state consists of the memory, main-pointer, sub-pointer, and stack). If the result is a memory-state, then it replaces the current memory-state with the returned state, if it isn't a memory-state, then it changes the value at this memory location to the return value.

There is also some new commands:
 * ~ If the code-block was called from outside of a code-block and the top of the stack contains a function, then it will exit the code-block similar to the @ command, but instead of returning the new memory-state, it returns the function that was at the top of the stack.
 * % If the top 2 values of stack are functions, it applies the top one to the one underneath it, and replaces them with the returned function.
 * = If the top entry of the stack is a memory-state, then it replaces the current memory-state with that one instead.

Outside of a code-block
This is similar to unlambda. The commands are:
 * ` Applies a function. (works like ` in unlambda)
 * &lt;</tt> K combinator function.
 * $</tt> S combinator function.
 * -</tt> I combinator function.
 * &gt;</tt> Iota combinator function.
 * '</tt> Creates a blank memory-state (all zero, empty stack, main and sub pointer to same location).
 * {}</tt> Creates a code-block.
 * ""</tt> With text between "" it creates a blank memory-state but the stack has the first character of the string on top, the last character of the string on the bottom.
 * !</tt> This function takes one argument, and returns a memory-state with the argument function as the only entry on the stack (the memory-state is otherwise blank).
 * #</tt> Works like the d command in unlambda.
 * </tt> Put zero or more functions between the parentheses, separated by semicolons. Stuff inside of the paremtheses are not evaluated right away. It creates a memory-state which is blank, except that each cell starting at the main pointer and going right, contains one of the items inside this list. The sub-pointer is on the cell directly after the last item of the list.
 * ^</tt> Call with current continuation. (works like c in unlambda)

If a code-block is applied to a memory-state, the code-block is executed with that memory-state and returns the new memory-state. If a code-block is applied to a non-memory-state, it acts as applied to what it would be if ! was applied to the argument function.

If a memory-state is applied to a memory-state, it returns a memory state which is a copy of the first one, but the contents of the stack of the second one is added onto the top of the stack of the first one. If a memory-state is applied to a non-memory-state, it returns the memory-state itself.

The preprocessor is also a bit different:
 * ?</tt>name{</tt>data}</tt> Define a inside-code-block macro (case sensitive!). If used outside of a code-block, it is replaced with the code-block in {}</tt>
 * ?</tt>name<tt>|</tt>data<tt>|</tt> Define a outside-code-block macro (case sensitive!). Cannot be used inside of a code-block.
 * name Use macro
 * number indicated a church integer function.
 * <tt>//</tt> Comment until end of line
 * <tt>??"</tt>file<tt>"</tt> Loads a include file. It works similarly to the PATH variable in UNIX.

Examples
Macro to print string: ?print{:[.#::]} `print "Hello, World!"

More macros to deal with strings: ?print{:[.#::]} ?concat|``$`<`$-<| ?chr|``$`<{;#:}``$``$-`<{+}`<'| ?reverse{:[>:]<[<]>[;#:>]}