What about something like this?

```
function Base.:^(x::Any, exponent::Tuple{Function,Integer})
op, p = exponent
p == 1 ? x : reduce(op, fill(x, p))
end
```

```
julia> typeof(1.0) |> supertype^(∘,3)
Number
julia> 3^(+,3) # Iterated addition -> Scalar multiplication
9
julia> 3^(^, 3) # Tetration 😄
19683
```

Implementation and syntax is obviously up for debate: For example, closure could work too e.g. `3 ^(+) 3`

, but I couldn’t figure out how to do it; I don’t know how to return an anonymous function that behaves like an operator.

I feel like a more general exponentiation operator has several benefits:

- Convenient and intuitive iteration of any closed binary operator (e.g. the main post) without having to implement a new
`^`

method for custom types
- When you have more than one product-like operation defined, you can eliminate ambiguity as to which operation your exponentiation is referring to.
- If you want to be more strict, instead of overloading
`^`

for custom types to mean iteration of some non-`*`

operator, you can instead specify exactly what you mean without much loss in convenience.
- Code golf

As for how useful it would be in practice…I’m not the person to ask.

My dream is for regular exponentiation `x^p`

to just be a special case via

```
(^)(x::Any, p::Integer) = x^(*, p)
```

⠀

See related this thread I made.