A common problem in the Lisp world involves demonstrating how in spite of the language's use of prefix notation, it is so robust as to allow for infix notation at the same time.

In other words, normally, we might put together a series of mathematical calculations like this:

```
(/ (- (+ 38 48) 2) 2)
```

Alternatively, we could also write a function to support the following, as well:

```
(infix 38 + 48 - 2 / 2)
```

Let's look at how the `infix`

function might be written. A common Lisp style would be to write the function using recursion. We would treat the arguments to `infix`

as a stack, pulling them off one at a time and operating on an accumulator.

```
(defn infix [val & others]
(loop [acc val
stack others]
(if (empty? stack)
acc
(let [op (first stack)
b (second stack)
rem (rest (rest stack))]
(recur (op acc b) rem)))))
```

Above, we treat the first argument to `infix`

as the accumulator `acc`

which will hold the result of the various operations. The `stack`

binding will hold all the remaining operations and numbers. Our base case occurs when the `stack`

binding is empty, at which point we hand back our accumulator and have a result. Otherwise, using `let`

for clarity, we bind an operator `op`

, the first element from the `stack`

list, and a number `b`

, the second element. What remains will be everything from the third element onward, what is slightly clumsily done here with two calls to `rest`

. With the bindings in place, we make a recursive call to `infix`

, this time passing the result of the operation on the accumulator and our next number, as well as the remaining operations or numbers.

What makes the problem interesting is its highlighting how easy it is to store functions like `+`

, `-`

, `*`

, and `/`

in a list and then later call them. In particular, in my mind, it's the line `(op acc b)`

that shows how cool a Lisp can be.

Now the solution above is rather verbose. The use of `loop`

and `recur`

comes from my having learned Lisp with The Little Schemer. In writing Clojure code, I find it helpful to start with a recursive algorithm using `loop`

and then refactor towards a tighter implementation when possible.

A cleaner implementation of `infix`

in Clojure might look something like the following. (N.B. The code below is not my own and is taken from the collection of solutions to problem 135 on 4clojure.)

```
(defn infix
([x op y]
(op x y))
([x op y & xs]
(apply infix (cons (infix x op y) xs))))
```

By defining two method signatures with distinct arities, we can set up our list of numbers and operations, and then call `apply`

with our simple method signature to get a result.

Taking the example above, i.e., `(infix 38 + 48 - 2 / 2)`

, our initial call to `infix`

takes the first three elements from the passed arguments, e.g., `38`

. `+`

, and `48`

, and calls `infix`

again, this time using the simple `(op x y)`

code. From there, we call `cons`

with `86`

and `(- 2 / 2)`

, to get the list `(86 - 2 / 2)`

. From there, it's a simple matter of invoking our `infix`

method on the list, which will produce a solution.