WalrusOS/Walc
Walculator is a program designed for use in command shells that comes bundled with the WalrusOS. It is designed as an esoteric sort of desktop calculator that works in reversepolish notation. It includes modules for Geometry, Arithmetic, Complex and similar numbers, Set Theory, Logic, and String Manipulation. It supports variables, registers, and a deque for data manipulation.
It is accessed via the walc
command, which serves as an acceptable alternative name, hence the page name.
Commands
Walculator usage is something like using GHCi. When a nonspeciallymarked command is typed, standard expressions are used; when a command starts with a special character (specifically, the colon), it behaves as a command for modifying, examining, or interacting with the runtime of the program.
Expression commands are written in standard RPN, that is, they work as stack manipulation: Data is PUSHed onto the stack and operations POP their arguments before PUSHing the result. Operators are, generally, typable ASCII, but unicode may be used.
Usage
As has been mentioned, interacting with Walculator is simple: you type a command (with spaces separating individual subcommands) and hit enter, then it gets executed as an example to other members of the resistance.
Values
Individual subcommands are simple:
 A subcommand matching the regex
^?[09]+(\.[09]+)?$
is treated as a doubleprecision floatingpoint number (or bigfloat, if the implementation allows) or long integer (or bigint, if the implementation allows), based on the presence of a decimal point. It is pushed on the deque when encountered.  A subcommand matching the regex
^?0b[01_]+$
is treated as a binary integer, with underscores having no meaning (being removed from the string prior to interpretation). The number is converted to an integer then pushed onto the deque when encountered.  A subcommand matching the regex
^?0t[02_]+$
is treated as a ternary integer, with underscores having no meaning (being removed from the string prior to interpretation). The number is converted to an integer then pushed onto the deque when encountered.  A subcommand matching the regex
^?0q[03_]+$
is treated as a quaternary integer, with underscores having no meaning (being removed from the string prior to interpretation). The number is converted to an integer then pushed onto the deque when encountered.  A subcommand matching the regex
^?0o[07_]+$
is treated as an octal integer, with underscores having no meaning (being removed from the string prior to interpretation). The number is converted to an integer then pushed onto the deque when encountered.  A subcommand matching the regex
^?0x[09afAF]+$
is treated as a hexadecimal integer. The number is converted to an integer then pushed onto the deque when encountered.  A subcommand starting and ending with a double quote is treated as a string, with the quotes stripped before usage and % codes (as used in URLs) evaluated. The evaluated string is pushed onto the deque when encountered.
 A subcommand matching the regex
^[azAZ_][azAZ09_]$
is interpreted as a name. It is called when encountered.  A subcommand matching the regex
^\\[azAZ_][azAZ09_]$
is interpreted as an anonymous name. It is pushed onto the deque when encountered.  A subcommand equal to "[" starts list mode, which starts compiling its arguments into a list.
 A subcommand equal to "]" exits list mode and pushes the list onto the stack
 A subcommand equal to "{" starts block mode and starts compiling commands as a block instead of executing them. If already in block mode, add 1 to block mode counter.
 A subcommand equal to "}" subtracts one from the block mode counter and, if it is equal to zero, exits block mode and pushes the block onto the stack.
 A subcommand not matching any of the above regexes is treated as an operator, which pops its arguments from the deque then pushes the result onto it or otherwise manipulates the values in the deque.
Operators and Builtin Functions
Arithmetic  

Operator  Name  Meaning  Type  Example 
S

INC  Pop a value, push its successor  (a  b)

(5  6)

P

DEC  Pop a value, push its predecessor  (a  b)

(5  4)

+

ADD  Pop two values and push their sum  (a b  c

(5 6  11)



SUB  Pop two values off the stack, push the difference between the second and the first.  (a b  c)

(5 2  3)

'

NEGATE  Pop a value and push its additive inverse  (a  b)

(5  5)

*

MULT  Pop two numbers and push their product  (a b  c)

(5 12  60)

/

DIV  Pop two numbers, divide the second by the first  (a b  c)

(6 2  3)

//

FLOORDIV  Pop two values, divide the second by the first and floor the result  (a b  c)

(6 4  1)

/'

RECIP  Pop a value and push its multiplicative inverse (its reciprocal)  (a  b)

(5  0.2)

%

MOD  Pop two values and push the remainder when the second is integer divided by the first  (a b  c)

(12 5  2)

**

EXP  Pop two values and raise the second to the power of the first  (a b  c)

(5 3  125)

**%

EXPMOD  Calculate a**b%c efficiently  (a b c  d)

(12 2 100  44)



ABS  Pop a number, push its absolute value  (a  b)

(5  5)

Special Types  
Operator  Name  Meaning  Type  Example 
*i

IMAGINE  Pop a number and push it multiplied by i  (n  i)

(5  5i)

CONJ

CONJUGATE  Pop a number and push its (complex or other) conjugate  (z  z*)

(2+5i  25i)

String and List Manipulation  
Operator  Name  Meaning  Type  Example 
++

JOIN  Concatenate one list onto another  (a<t> b<t>  c<t>)

("walrus " "man"  "walrus man")

!!

INDEX  Get a value by index  (i l<t>  t)

(1 [1, 2, 3]  2)



 
Trigonometry  
Operator  Name  Meaning  Type  Example 
SIN

SINE  Pop a number, push its sine  (a  b)

(45  1)

COS

COSINE  Pop a number, push its cosine  (a  b)

(30  0.154251449887584)

TAN

TANGENT  Pop a number, push its tangent  (a  b)

(12  0.635859928661581)

ASIN

ASIN  Pop a number, push its inverse sine  (a  b)


ACOS

ACOS  Pop a number, push its inverse cosine  (a  b)


ATAN

ATAN  Pop a number, push its inverse tangent  (a  b)


Stack Manipulation  
Operator  Name  Meaning  Type  Example 
:

DUP  Duplicate the value on the top of the stack  (a  a a)

(5  5 5)

\

SWAP  Pop two values from the stack and push them in the order they were popped  (a b  b a)

(1 2  2 1)

$

DROP  Pop a value off the top of the stack and discard it.  (a  )

(5  )

:'

DUP PRIME or or DUP GROUP or DROUP  Pop an int "n" off the stack then duplicate the top n values on the stack. If n=0, duplicate the entire stack on top of itself.  (n a[n]  a[n] a[n])

(3 1 2 3  1 2 3 1 2 3

\'

SWAP PRIME or INVERT GROUP  Pop an int "n" off the stack then invert the top n values on the stack. If n=0, invert the whole stack.  (n a[n]  invert(a[n]))

(4 1 2 3 4  4 3 2 1)

$'

DROP PRIME or DROP GROUP  Pop an int n off the stack then pop n more items off the stack and discard them  (n a[n]  )

(5 1 2 3 4 5  )

:''

DUP DOUBLE PRIME or LOTS  Pop an int n off the stack, pop a value v off the stack, push n copies of v onto the stack.  (n v  v*n)

(3 1  1 1 1)

:'''

DUP TRIPLE PRIME or GROUP LOTS  Pop an int n off the stack, pop an int o off the stack, duplicate the top o items on the stack n times.  (n o a[n]  a[n]*o

(2 2 1 2  1 2 1 2 1 2

ROT

ROT  Rotate the top three values on the stack  (a b c  b c a)

(1 2 3  2 3 1)

REVROT

REVROT  Reverse rotate the top three values on the stack  (a b c  c a b)

(1 2 3  3 1 2)

ROT'

ROT PRIME  Pop n, rotate the top n items on the stack  (n a[n]  rotate(a[n]))

(5 1 2 3 4 5  2 3 4 5 1)

REVROT'

REVROT PRIME  Pop n, reverse rotate the top n items on the stack  (n a[n]  reverse_rotate(a[n]))

(5 1 2 3 4 5  5 1 2 3 4)

ROT''

ROT DOUBLE PRIME  Pop n, rotate the top 3 elements on the stack by n  (n a[3]  rotate(a[3], n)

(2 1 2 3  3 1 2)

REVROT''

REVROT DOUBLE PRIME  Pop n, reverse rotate the top 3 elements on the stack by n  (n a[3]  reverse_rotate(a[3], n)

(2 1 2 3  2 3 1)

ROT'''

ROT TRIPLE PRIME  Pop n, pop o, rotate the top o elements on the stack by n  (n o a[o]  rotate(a[o], n)

(4 2 1 2 3 4  3 4 1 2)

REVROT'''

REVROT TRIPLE PRIME  Pop n, pop o, reverse rotate the top o elements on the stack by n  (n o a[o]  reverse_rotate(a[o], n)

(4 2 1 2 3 4  4 3 1 2)

ROLL

ROLL  Rotate the deque such that the front element is moved to the back  (b  ...b

(1  ...1)

REVROLL

REVROLL  Rotate the deque in reverse (back becomes the front)  (...a  a)

(...1  1)

ROLL'

ROLL PRIME  Pop n, roll the deque by n slots  (n a[n]  ...reverse(a[n]))

(2 1 2  ... 2 1)

REVROLL'

REVROLL PRIME  Pop n, reverse rotate the deque by n slots  (n ... a[n]  reverse(a[n]))

(3 ... 1 2 3  3 2 1

CHUNKROLL

CHUNKROLL  Pop n, move the front n elements in the deque to the back  (n a[n]  ...a[n])

(2 1 2  ...1 2)

CHUNKREVROLL

CHUNKREVROLL  Pop n, move the back n elements in the deque to the front  (n ... a[n]  a[n])

(3 ... 1 2 3  1 2 3
