# clojure Macros Simple Infix Macro

## Example

Clojure uses prefix notation, that is: The operator comes before its operands.

For example, a simple sum of two numbers would be:

```(+ 1 2)
;; => 3
```

Macros allow you to manipulate the Clojure language to a certain degree. For example, you could implement a macro that let you write code in infix notation (e.g., `1 + 2`):

``````(defmacro infix [first-operand operator second-operand]
"Converts an infix expression into a prefix expression"
(list operator first-operand second-operand))
``````

Let's break down what the code above does:

• `defmacro` is a special form you use to define a macro.
• `infix` is the name of the macro we are defining.
• `[first-operand operator second-operand]` are the parameters this macro expects to receive when it is called.
• `(list operator first-operand second-operand)` is the body of our macro. It simply creates a `list` with the values of the parameters provided to the `infix` macro and returns that.

`defmacro` is a special form because it behaves a little differently compared to other Clojure constructs: Its parameters are not immediately evaluated (when we call the macro). This is what allows us to write something like:

``````(infix 1 + 2)
;; => 3
``````

The `infix` macro will expand the `1 + 2` arguments into `(+ 1 2)`, which is a valid Clojure form that can be evaluated.

If you want to see what the `infix` macro generates, you can use the `macroexpand` operator:

``````(macroexpand '(infix 1 + 2))
;; => (+ 1 2)
``````

`macroexpand`, as implied by its name, will expand the macro (in this case, it will use the `infix` macro to transform `1 + 2` into `(+ 1 2)`) but won't allow the result of the macro expansion to be evaluated by Clojure's interpreter. PDF - Download clojure for free