# 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 ¬ ¬

### logic gates

#### AND

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

#### OR

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

#### NOR

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

0 ¬ 1 - 1 ¬ 0 # 11 R ¬

#### NAND

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

#### XOR

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

#### XNOR

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