The problem with infix notation is that parentheses are often needed, and it doesn't generalize well to functions of more than 2 inputs.

The problem with prefix and postfix notation is that you need to know by heart how many inputs a given function takes, and you get no explicit reminder of where the scope of the function ends. This is no big deal for computing purposes, where you just have to avoid ambiguity, but it's annoying for human readability to always have to work out for yourself where the scope of each function ends.

In infix, with something like (a+b.)*(c+d), I can tell at a glance that the * is being applied to two small sub-expressions. In postfix, that would be ab+cd+*, which saves on parentheses and is therefore more concise, but makes it harder to immediately parse the inputs of *, since they aren't explicitly delimited.

So I figured the ideal mixture of the two would be to have the function name itself serve as the delimiter of its inputs. For a function f, you would have "f (inputs) \f". So, for example,

a+b+c+d

becomes

+a b c d\+

And the previous example of

(a+b.)*(c+d) in infix, which is

a b + c d + * in postfix, would be

*+a b\+ +c d\+\* in "outfix".

That looks odd at first, but once you get used to seeing + and \+ as delimiters like parentheses, it becomes easy to scan over the expression and immediately see that the terms of the multiplication are two small sub-expressions.

Outfix may seem less concise on the face of it, but it can be easily improved by omitting the closing delimiter at the end of the expression. This turns the above example into

*+a b\+ +c d\+

The final \* is unnecessary, because the end of the expression implicitly closes the main function, in this case multiplication.

But furthermore, because every function has distinct delimiters, closing one function can implicitly close others. For example, the final \+ above could also be omitted, giving

*+a b\+ +c d

Since +c d\+ is inside the multiplication, the end of the multiplication would implicitly indicate the end of the addition as well. And the end of the multiplication in this case is itself implicitly established by the end of the expression.

We can take one final step by using the standard convention of assuming multiplication when no function is specified, which simplifies the expression down to

+a b\++c d

Now lets try comparing outfix, infix, and postfix on something more complicated. My go-to example for comparing notations is the quadratic formula. It's worth noting that unary functions need no closing delimiter, since they're assumed to simply apply to the immediately following term. Also, I'll use # for "plus or minus".

Infix:

(-b+#sqrt(b^2-4ac))/(2a)

Postfix (with unary negation, not binary subtraction):

b-b2^4a*c*-+sqrt#+2 a*/

Outfix (with unary negation and reciprocation):

+-b #sqrt+^b 2\^ -4ac\+\+/2a

Outfix doesn't exactly prove superior to infix here, but I'd say it's a heck of a lot easier to parse than postfix, and it doesn't lose much concision compared to infix either. Where outfix really shines is with multiple nested functions. For example:

f(x,g(y,h(z,w)))

becomes

fx gy hz w

In an example like above, it might seem ambiguous in general whether f, g, and h are functions or variables, but this can be easily resolved just by having a convention for distinguishing the two. For example, using regular print for variables, and for functions using cursive when writing or italic when typing. Giving

*f*x

*g*y

*h*z w

In this example the notation reduces to prefix. But the way I see it, that's the beauty of it. It reduces to something simple like prefix whenever the expression is easy to read in prefix, but naturally introduces delimiters when necessary. For example, the similar expression

f(g(h(x,y),z),w)

becomes

*fgh*x y\

*h*z\

*g*w

In prefix, you would need to parse the entire expression to find out that everything before w is a single term, and thus that w is the second input to f. But in outfix, as soon as you see the g, you can scan forward to the \g to see where that term ends, without having to parse everything in between.

I suppose you could go even further by allowing the notation to reduce to postfix when convenient by using a closing \f with an implied opening f at the start of the expression. So the previous example would be

x y\

*h*z\

*g*w\

*f*

Basically, this unifies prefix, postfix, and the use of delimiters into one notation that allows you to do whatever's most convenient for any given expression.