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)
* < K combinator function.
* $ S combinator function.
* - I combinator function.
* > Iota combinator function.
* ' Creates a blank memory-state (all zero, empty stack, main and sub pointer to same location).
* {} Creates a code-block.
* "" 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.
* ! 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).
* # Works like the d command in unlambda.
* () 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.
* ^ 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:
* ?name{data} Define a inside-code-block macro (case sensitive!). If used outside of a code-block, it is replaced with the code-block in {}
* ?name|data| 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.
* // Comment until end of line 
* ??"file" 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{:[>:]<[<]>[;#:>]}