In the **Function Macros** section we mentioned that Nessa has a code generation pattern that executes code. Since its complexity is far
from the rest, we will dedicate this section to explaining how it works.

## Syntax

The syntax of this pattern is simple:

```
{| inner_pattern |}
```

You can put any macro pattern you want inside those braces and the resulting text will be interpreted as Nessa code. The generated code 
will execute normally, even importing libraries if necessary, but you will have access to a special function
not available otherwise: the `emit` function.


This funtion, which takes as a parameter a single `String`, will send that string to a buffer that will accumulate everything emited 
throughout the execution of the code. After the execution ends, the buffer will be appended to the code generated by the macro. This is
essentially the same as *procedural macros* in *Rust*.

## Examples

Lets see a basic example that creates the expression `1 + 1`. In order to do this you do not need compile time code execution, but it will allow us to 
illustrate how they work. You could use the following:

```
syntax expr one_plus_one from "Example" {
    {| emit("1 + 1") |}
}

// Use it like this ...
print(Example);

// ... which compiles to this
print(1 + 1);
```

Of course, this is not very interesting because this macro has no interaction with the pattern that was matched. This can be changed easily by using different
inner patterns, so let's make a more complex example:

```
syntax expr n_plus_m from Arg(1{d}, a) "plus" Arg(1{d}, a) {
    {|
        let a = "$a";
        let b = "$b";

        emit(*a);
        emit(" + ");
        emit(*b);
    |}
}

// Use it like this ...
print(7plus32);

// ... which compiles to this
print(7 + 32);
```

As you can imagine, this opens up possibilities a lot when using macros, since you can even **import libraries** inside them. You can see an extreme example where
you embed an esoteric language inside Nessa using these macro patterns in the *Learn by example* section.