# ¥́

¥́ is an esolang by User:BoundedBeans intended to achieve a certain visual appearance, and to use a lot of his favorite symbol.

## Syntax

Every line should have exactly 20 regular characters and 20 combining diacritical marks. They should be paired up in such a way that each character attaches to exactly one mark.

The only allowed regular characters are: `ABCDEFGHIJKLMNOPQRSTUVWXYZ!?,_¥`, although everything except ¥ is only useful for comments.

Newlines can be either LF, CRLF, or CR, and an implementation should be able to handle all three. One way to do this is by replacing CRLF with LF, then replacing CR with LF to get rid of any stragglers.

## Basics

The semantics of `¥` is determined by its diacritical mark. It is kind of like a LISP.

### Space

Elements of lists should be separated by whatever this is called (`¥̍`).

### Lists

The grave and acute accent marks (`¥̀¥́`) represent a list (of course as cons pairs, as a LISP typically is. A proper list is a list where the last pair's cdr is the empty list. The unquoted empty list represents the empty list, but an unquoted list with any elements represents the first element called with all of the rest, and if they are also unquoted lists, more evaluation will be done to get the elements.

### Quoting

Of course, lists usually call something. To quote a list, you can use the dot (`¥̇`) before the opening parenthesis. Same deal with a symbol.

You can use an umlaut followed by a dot (`¥̈¥̇`) to unquote stuff (run code to obtain an element of a quoted list).

An umlaut followed by another umlaut (`¥̈¥̈`) represents unquote splicing, which is a bit like unquote except that if the function returns a proper list, it will spread its elements into multiple elements of the quoted list.

### Symbols

A symbol is represented by the tilde (`¥̃`) followed by a sequence of circumflexes and carons (`¥̂¥̌`). They normally evaluate to a variable's value, or 0 if not assigned. They can be quoted to mean just the symbol. Symbols are typically notated outside of the program as UTF-8 representations of the binary, while the binary contains valid UTF-8 (0 - circumflex, 1 - caron) plus a caron at the end, which means they typically should take up multiples of 8 marks plus one. Builtins have nothing instead, taking up an exact multiple of 8 marks. Implementation additions should add a circumflex at the end, while multiples of 8 marks plus two ending in circumflex circumflex are reserved by compiler generated variables (of course you can still use them though)

### Numbers

Numbers are represented with the ring (`¥̊`) followed by the number in binary (0 - circumflex, 1 - caron). They are unbounded and cannot be negative.

A comment is any valid syntax character plus a macron (`¥̄`). It is an error if any character besides `¥` has any mark except the macron, however it is completely fine for `¥` to have a macron.

## Pre-bound symbols

UTF-8 representation Use
`F` Takes a list of symbols and one or more expressions to evaluate. Returns a function. Special form, won't work with `A`
`L` Takes a list with alternating symbols and values and one or more expressions to evaluate, binds the symbols and runs the expression. The later symbols have access to the earlier ones. Special form, won't work with `A`
`R` Takes arguments. Tail recursion inside of F, but doesn't have to be in the tail (if it isn't, the rest of the function will be skipped). Special form, won't work with `A`
`C` Cons
`[` Car
`]` Cdr
`A` Apply
`?` If the first expression evaluates to zero, run the second, otherwise, run the third. Special form, won't work with A. Short-circuiting.
`+`, `-`, `*`, `/` Standard math operations.
`<` Less than
`=` Equals.
`&` Logical NAND.
`|` Bitwise NOR.
`}` Takes a list containing two numbers. Uses the first number to make the base binary of the symbols, then prepends the second number of zeroes. If the first number is zero, it represents the empty symbol.
`{` Takes a symbol, returns a list containing two elements. The first is the binary number represented by the symbols name. The second is the number of zeroes it starts with before hitting either a one or the end of the symbol.
`@` Takes a list, evaluates it as a ¥́ expression and returns the result.
`\$` Takes a list of numbers, reads it as UTF-8 ¥́ expression syntax, returns the reading result (`@` is still necessary if you want to run it.
`,` Inputs a byte, turns it into a number, returns it. 256 indicates EOF.
`.` Outputs a number modulo 256 as a byte.

## Examples

### Print 'H'

```¥̀¥̃¥̂¥̂¥̌¥̂¥̌¥̌¥̌¥̂¥̍¥̊¥̂¥̌¥̂¥̂¥̌¥̂¥̂¥̂
¥́P̄R̄ĪN̄T̄_̄H̄!̄_̄_̄_̄_̄_̄_̄_̄_̄_̄_̄_̄
```

### Truth-machine

```¥̀¥̃¥̂¥̌¥̂¥̂¥̌¥̌¥̂¥̂¥̍¥̀¥̃¥̌¥̍¥̀¥̃¥̂¥̂¥̌
¥̂¥̌¥̌¥̂¥̂¥́¥̍¥̃¥̂¥̂¥̂¥̂¥̂¥̂¥̂¥̂¥̌¥̍¥̀¥̃
¥̂¥̂¥̂¥̌¥̌¥̌¥̌¥̌¥̍¥̀¥̃¥̂¥̂¥̌¥̂¥̌¥̌¥̂¥̌¥̍
¥̃¥̌¥̍¥̊¥̌¥̌¥̂¥̂¥̂¥̂¥́¥̍¥̀¥̃¥̂¥̌¥̂¥̂¥̂¥̌
¥̌¥̂¥̍¥̀¥́¥̍¥̀¥̃¥̂¥̂¥̌¥̂¥̌¥̌¥̌¥̂¥̍¥̊¥̌¥̌
¥̂¥̂¥̂¥̂¥́¥́¥̍¥̀¥̃¥̂¥̌¥̂¥̂¥̂¥̌¥̌¥̂¥̍¥̀¥́
¥̍¥̀¥̃¥̂¥̂¥̌¥̂¥̌¥̌¥̌¥̂¥̍¥̊¥̌¥̌¥̂¥̂¥̂¥̌¥́
¥̍¥̀¥̃¥̂¥̌¥̂¥̌¥̂¥̂¥̌¥̂¥́¥́¥́¥́¥̍¥̀¥̃¥̂¥̂
¥̂¥̂¥̂¥̂¥̂¥̂¥̌¥́¥́¥̄¥̄¥̄¥̄¥̄¥̄¥̄¥̄¥̄¥̄¥̄
```

Prettified but syntax error:

```¥̀¥̃¥̂¥̌¥̂¥̂¥̌¥̌¥̂¥̂¥̍¥̀
¥̃¥̌¥̍
¥̀¥̃¥̂¥̂¥̌¥̂¥̌¥̌¥̂¥̂¥́¥̍
¥̃¥̂¥̂¥̂¥̂¥̂¥̂¥̂¥̂¥̌¥̍
¥̀
¥̃¥̂¥̂¥̂¥̌¥̌¥̌¥̌¥̌¥̍
¥̀
¥̃¥̂¥̂¥̌¥̂¥̌¥̌¥̂¥̌¥̍
¥̃¥̌¥̍
¥̊¥̌¥̌¥̂¥̂¥̂¥̂
¥́¥̍
¥̀¥̃¥̂¥̌¥̂¥̂¥̂¥̌¥̌¥̂¥̍
¥̀¥́¥̍
¥̀¥̃¥̂¥̂¥̌¥̂¥̌¥̌¥̌¥̂¥̍
¥̊¥̌¥̌¥̂¥̂¥̂¥̂
¥́
¥́¥̍
¥̀¥̃¥̂¥̌¥̂¥̂¥̂¥̌¥̌¥̂¥̍
¥̀¥́¥̍
¥̀¥̃¥̂¥̂¥̌¥̂¥̌¥̌¥̌¥̂¥̍
¥̊¥̌¥̌¥̂¥̂¥̂¥̌
¥́¥̍
¥̀¥̃¥̂¥̌¥̂¥̌¥̂¥̂¥̌¥̂¥́
¥́
¥́
¥́¥̍¥̀¥̃¥̂¥̂¥̂¥̂¥̂¥̂¥̂¥̂¥̌¥́¥́
```