# !or

*The title of this article is not correct because of technical limitations. The correct title is actually*.**!|**

**!|** is a esolang created by Lon233bcc (talk) 20:44, 20 August 2022 (UTC)

(it's called not or because the original language the only commands were not / or boolean logic.

But I've changed it to include & !& ^ !^ !| commands as well.

The idea for this language came to me when I tried to make a full adder using not and or commands in lua

Input/Output Commands:

Command | Description |
---|---|

`_` |
Put in front of any input command to take multiple chars/digits/bits of input (until the user presses enter) |

`~` |
Get's one bit of input |

`#` |
Gets one digit of input as a list of bits (note: when putting a _ before it, each digit will NOT have it's own list, it will be one list of bits to represent the entire number) |

`$` |
Gets one character of ascii input as a list of containing a list that represents the ascii value in binary |

``` |
Outputs one bit of output |

`.` |
Outputs a integer |

`,` |
Outputs a ascii character one 8 bits are put into it. Calling it with no bits in it will output a newline by defualt, clear it with %, |

If A or B is a list, it will preform the operation on every bit of A and B. (Assuming A/B is a list of bits and not a list of lists), if either one is shorter, it will assume bits that don't exist are 0 will only return 1 ALL bits return that value

Precede a logic command with a ! to output the opposite of what that command normally does

Putting any logical Operator after a list with no B argument will perform that operation on the entire list at once with and produce a 1 or 0 such a (A!^B)& will output a 1 only if A is equal to B

Logic Commands:

Command | Description |
---|---|

`!A` |
Will preform logical NOT on A |

`A&B` |
Will preform logical AND on A and B |

`A|B` |
Will preform logical OR on A and B |

`A^B` |
Will preform logical XOR on A and B |

`()` |
Expressions in parentheses are done first. |

Loops:

Command | Description |
---|---|

`[]` |
Infinite loop |

`A[]` |
Loop while A is 1 (Obviously doesn't work if A is a list) |

`[]B` |
Loop while B is 0 (Obviously doesn't work if B is a list) |

`A[]B` |
Loop while A is 1 and B is 0 (Obviously doesn't work if A or B is a list) |

`A->i[]` |
Loop the length of List A times with i as the iterator variable. If there is already a variable called i it will double as the starting value. be sure to clear i after the loop by doing %i |

`?()` |
Break out of the current loop if the expression in () is 1, will preform A& if supplied with multiple bits |

`?!()` |
Break out of the current loop if the expression in () is 0, will preform A& if supplied with multiple bits |

List Compression:

{0x3} is the same as {0 0 0}

{(1 0)x2} is the same as {1 0 1 0}

{{1}x2} is the same as {{1}{1}} You can put multiple {} in parentheses to do the same thing as {(1 0)x2} does but with {}

This can make strings slightly less big.

Lists start indexing at 1 instead of 0 because I hate you.

List Commands:

Command | Description |
---|---|

`A{}` |
Will set A to a empty list |

`*A` |
Returns the length of A as a binary number. |

`A=B` |
Append the shorter list with 0's until both lists have equal length |

`A>B` |
Append the last value of A onto B then destroy the last value of A |

`B<A` |
Prepend the first value of A onto B then destroy the first value of A |

`A:B` |
Append B to A |

`&A` |
Output a 1 if all the bits in A are 1 |

`|A` |
Output a 1 if any of the bits in A are 1 |

`!^A` |
Output a 1 if all the bits in A are the same |

`{1 0}.{1 0}` |
Will return the second item of list {1 0} (so 0) doing {1 0}.2 can also be used |

Variable COMMANDS:

Command | Description |
---|---|

`A` |
Will set A to 0 |

`A 1` |
Will set A to 1 |

`%A` |
Will destroy A (if done on list it will only destroy the contents of the list, unless it's empty) |

`A>B` |
Move the value of A into B then destroy A |

FUNCTIONS: (functions are secretly magical shapeshifting lists.)

Command | Description |
---|---|

`+[A B][CODE]` |
Makes function called + with paramenters A and B
can be run by doing A + B (assuming you only want the first value returned) (And there is only two or less paramenters) |

`R: Value` |
Adds to the return list (what the function list will turn into) |

`->+` |
Shapeshifts (calls) the function |

Shapeshift (call) function called + with paramenters set to A and B | |

`A>+` |
Move the value of A into + (TIP: if for some reason you want to use > and not : to move values into functions putting it in {} (like {A}>+ won't destroy A, but it would make more sense to just use :) |

`%+` |
Clear the function called + to be ran again |

`END or \` |
END the function early. |

Code stuff:

// Printing text (Prints whatever is in Str then a newline) (remove the last , to remove the newline) Str->i[,:Str.i%,]%i%,,

// If statement (runs Code if A=B) {1}->[?(A^B) // Code]

Truth Machine

~[`1]`0

Cat Program:

[$,%,]

Characters that are not accepted in variable names: (anything else is accepted)
~!@#$%^&*()`=_[]{}|\/><.,:OR SPACE TAB NEWLINE