<p>Say I need some very special multiplication operator. It may be implemented in following macro:</p>

<pre><code>macro @&lt;&lt;!(op1, op2)
{
    &lt;[ ( $op1 * $op2 ) ]&gt;
}
</code></pre>

<p>And I can use it like</p>

<pre><code>def val = 2 &lt;&lt;! 3
</code></pre>

<p>And its work.</p>

<p>But what I really want is some 'english'-like operator for the DSL Im developing now:</p>

<pre><code>macro @multiply(op1, op2)
{
    &lt;[ ( $op1 * $op2 ) ]&gt;
}
</code></pre>

<p>and if I try to use it like</p>

<pre><code>def val = 2 multiply 3
</code></pre>

<p>compiler fails with 'expected ;' error</p>

<p>What is the problem? How can I implement this infix-format macro?</p>

Straight from the compiler source code:
```
```
namespace Nemerle.English
{
  [assembly: Nemerle.Internal.OperatorAttribute ("Nemerle.English", "and", false, 160, 161)]
  [assembly: Nemerle.Internal.OperatorAttribute ("Nemerle.English", "or", false, 150, 151)]
  [assembly: Nemerle.Internal.OperatorAttribute ("Nemerle.English", "not", true, 181, 180)]  

  macro @and (e1, e2) {
    <[ $e1 && $e2 ]>
  }

  macro @or (e1, e2) {
    <[ $e1 || $e2 ]>
  }

  macro @not (e) {
    <[ ! $e ]>
  }
```
```
You need to sprinkle OperatorAttributes around and it will work. Btw, OperatorAttribute is defined as follows:
```
```
public class OperatorAttribute : NemerleAttribute
{
  public mutable env : string;
  public mutable name : string;
  public mutable IsUnary : bool;
  public mutable left : int;
  public mutable right : int;
}
```
```