One of the main features of Ryna is that it allows the programmer to define many new elements of the syntax.
One of these are **literals**, which can be defined for any valid class. Let's see how this works.

## Basic classes

The firt part of this is the syntax of basic types. Not all of them have types, but the ones that do are the
basic building blocks for more compplicated literals. Here is a table with the basic types that do have a syntax:


| Type     | NDL Pattern           | Regex        |
| -------- | --------------------- | ------------ |
| `Int`    | `["-"] 1{d}`          | `-?\d+`      |
| `Float`  | `["-"] 1{d} "." 1{d}` | `-?\d+\.\d+` |
| `Bool`   | `"true" | "false"`    | `true|false` |
| `String` | No constaint          | `.*`         |

Everything that follows these syntaxes can be parsed as an instance of this type.

## Creating a literal

In order to create a new literal you first have to create a new class that the literal will be parsed to. Also, this
class's attributes must also have at least a syntax. Here is an example class thaht represents a number of *D&D* dice rolls: 

```
class Dice {
    rolls: Int;
    sides: Int;
}

let d = Dice(5, 20); // Throw a 20 sided dice 5 times 
```

Now, the readers that have played *D&D* know that this value is often represented as `5D20`. We can define this simple syntax
using Ryna:

```
class Dice {
    syntax from Arg(1{d}, rolls) "D" Arg(1{d}, sides);

    rolls: Int;
    sides: Int;
}

let d = 5D20; // Throw a 20 sided dice 5 times 
```

Here the `Arg` NDL marker tells the interpreter that the syntax of a `Dice` consist on an integer (the `rolls`) followed
by a `D` and, finally, another integer (the `sides`). After this, the class `Dice` can also be parsed inside an NDL pattern.
Now let's take a look at a different use case: an **integer array**:

```
class Ints {
    syntax from "[" Arg(1{d}, ints) {", " Arg(1{d}, ints)} "]";

    ints: Array<Int>;
}

let a: Ints = [1, 2, 3];
```

This case shows how the interpreter works when an `Arg` marker with the same **target** is matched several times. Each time it matches,
the result is parsed inside an `Array` of the type it parses.