# DDuuaall

DDuuaall is a language invented by User:A, inspired by Vyxal's zipmap.

## Special Arity Rules

The so-called complement is usually number negation for numbers, or reversing for strings/lists.

You push a nilad along with its complement, the complement is pushed after the original nilad.

You apply the defined operation, along with a "complement-operation". The result of the complement operation is pushed after the intended operation.

With two list operands, it vectorizes, if possible (unless the instruction defines otherwise). When the TOS is a list operand, it reduces the dyad by the list.

With a list operand on the bottom and a number operand on the top, the instruction implements its own method of evaluation.

## Instruction list

Instruction Main behavior Complement behavior
`\` (Triad) Triple swap: a b c -> c a b -
`=` (Dyad) Vectorizing equality -
`+` (Dyad) Vectorizing addition/string concatenation -
`-` (Dyad) Vectorizing subtraction -
`*` (Dyad) Vectorizing Multiplication/string repeat -
`/` (Dyad) Vectorizing division -
`\$` (Dyad) Swap two items on the stack -
`%` (Dyad) Vectorizing modulus -
`~` (Dyad) Remove items -
`L` (Dyad) Return the top operand, pop the second-to-top operand -
`R` (Monad) 1-range, reverse for lists Reverse 1-range, identity for lists
`~` (Monad) Remove the last item of the list Remove the first item of the list
`_` (Monad) Pop the stack Duplicate the stack
`O` (Monad) Pops + Outputs TOS, disables implicit output. (exception to the monad rule) -
`"xyz"` (Nilad) Push "xyz" Push "xyz" reversed
`0-9` (Nilad) Push the number formed by the construction Push the negative of the number formed by the construction
`I` (Nilad) Push the input (exception to the nilad rule) -

## I/O Specifications

There's implicit input, but you can also take explicit input via `I`.

The whole stack's content is joined and outputted at the end of the program.

## Example programs

### Is it odd or even?

```R=+
```

#### Explanation

```Assume the input = 3 right now.

R    1-range.              Push [1, 2, 3] (original function) and [3, 2, 1] (complement function)
=   Vectorizing equality. Push [0, 1, 0]
+  Sum the list.         Push 1          (If the stack only has one list item, DDuuaall reduces over the list by the dyadic operation)
```

### Hello, World!

```"Hello, World!"0+*+
```

#### Explanation

```"Hello, World!"     String literal. Push "Hello, World!" (original) and "!dlroW, olleH" (complement)
0    Number literal. Push 0 and -0 (aka push 2 0's)
+   Add the two copies of 0.
*  Repeat the complement string by 0.
+ Join the empty string by the original string.
```

### Primalty Tester

```RL~UI\$L\$%0+=+0
```

#### Explanation

```Assume input = 4 here.

R                Range. [1, 2, 3, 4] and [4, 3, 2, 1]
L               Left.  [1, 2, 3, 4]
~              Pop.   [1, 2, 3]    and [2, 3, 4]
U             Intersect. [2, 3]
I            Input. [2, 3], 4, -4
\$           Swap.  [2, 3], -4, 4
L          Left.  [2, 3], 4
\$         Swap.  4, [2, 3]
%        Mod.   [1, 0]
0       Zero.  [1, 0], 0, 0