# pass a symbol

pass a symbol or PAS (lol) is an esolang where the whole idea is you can make your own commands. Although this should not be considered a metalang (I think), it is a category anyway.

## How It Works

You start by putting a top binary number, then a symbol, and then another binary digit, like this:

```0
E
1
```

This defines E, which will take input as a binary number and output another one. If it has input 0, it will output 1. BUT this does not mean that passing 1 gives 0. Since that's not defined, passing a 1 to E will give 1. To define a NOT gate with symbol E, it would be:

```0
E
1
-
1
E
0
```

This defines a NOT gate, and a - separates these definitions. There is a special symbol that can replace a binary digit, which is `i`. This symbol will take user input as a binary digit (or digits). For example, like this:

```i
E
0
```

Adding a `o` at the end of a binary digit at the bottom of a definition will make it output itself. To make it output in Unicode, a `\$` is used instead:

```0
E
1
#
0
E
o
```

Also, # separates definitions from the calculation. To make an operator pass the result it makes to itself recursively, a `^` is used at the start of the first definition, which will make it pass the result to itself. If you want it for a spesific output it can replace the input of a function. If this is done `~` Will break the loop. Putting an `X` at input will make it halt itself. One last thing: there is a tape extending infinitely to the right. `>` and `<` move around the tape, `(` is `o` but on the current cell, and `)` is `\$` (these only work after the `#` or in the output of a definition). Putting a `%` at the end of the output in a definition will put that into the tape, and putting a `*` instead of a binary number in the `#` section will take the current tape cell.

## examples

```^
0
E
0oX
-
1
E
11o
-
11
E
1o
#
i
E
```

infinite loop:

```^
0
E
0
#
0
E
```

Double layer buffer:

```0
¬
1
-
1
¬
0
#
0
¬
¬
```

```01
A
0
-
10
A
0
-
00
A
0
-
11
A
1
#
11
A
```

```10
R
1
-
01
R
1
-
11
R
1
-
00
R
0
#
11
R
```

```10
R
1
-
01
R
1
-
11
R
1
-
00
R
0
-
```
```0
¬
1
-
1
¬
0
#
11
R
¬
```

```01
A
0
-
10
A
0
-
00
A
0
-
11
A
1
-
0
¬
1
-
1
¬
0
#
11
A
¬
```

```10
X
1
-
01
X
1
-
11
X
0
-
00
X
0
#
11
X
```

```10
X
1
-
01
X
1
-
11
X
0
-
00
X
0
-
0
¬
1
-
1
¬
0
#
11
X
¬
```

## notes

• im not sure if this is even possible but isn't this both imperative and declarative?
• im pretty sure this is NOT turing complete