7

I have been learning Clojure and looking at Scheme and CL which introduced me to the world of prefix notation. At first I didn't like it but it is still starting to grow on me. To be honest though, there are still long calculations that are difficult for me to understand but I think that is an issue of me needing more exposure/practice and I'll get it.

But that leads me to the question: Which type of notation do you prefer and why?

Jetti
  • 5,163
  • 2
  • 26
  • 41
  • 2
    Maybe a duplicate of http://programmers.stackexchange.com/questions/2497/how-useful-are-infix-operators-in-a-programming-language – LennyProgrammers Dec 14 '10 at 17:04
  • @Lenny222 - That question is regarding the usefulness, I'm just asking about preference if given the choice. – Jetti Dec 14 '10 at 19:06
  • 4
    Discrimination! Where's the love for postfix? ;-) http://en.wikipedia.org/wiki/Forth_%28programming_language%29 – sdg Dec 14 '10 at 22:20

8 Answers8

14

I find infix notation easier to read, simply because I've been working with it ever since kindergarten.

Mason Wheeler
  • 82,151
  • 24
  • 234
  • 309
11

I have no preference. I can work well in either.

Not many programmers realize that prefix notation is actually the norm and infix is the oddball. After all, just about every language uses prefix notation for function/method calls. It's only a relatively small number of arithmetic and logic operators that are infix.

The more you look at our system of mathematical symbols, the more screwy you see they are. Some are infix (+, -, *), some are postfix (x2), some prefix (tan x), some under-fix (ratios and fractions), and some overfix. It's not as simple as PEMDAS.

Barry Brown
  • 4,095
  • 4
  • 25
  • 27
  • 5
    I suppose you wanted to say "Not realize many people that and actually is prefix notation the norm is infix the oddball". Parentheses omitted for clarity :P – back2dos Dec 14 '10 at 19:02
  • 1
    "After all, just about every language uses prefix notation for function/method calls" Actually method calls are infix in most mainstream languages, i.e. `receiver.method(arguments)`, not `method(receiver,arguments)`. – sepp2k Dec 14 '10 at 19:24
  • (with (edited the-answer) (of suggestion back2dos)) – Barry Brown Dec 15 '10 at 08:55
  • 1
    @back2dos: And I suppose *you* wanted to say "Realize not many programmers and that actually is prefix notation the norm is infix the oddball." Not only is it unfair to bring natural language into a discussion about artificial langauge, but also, to quote Wikipedia, "The overwhelming majority of the world's languages are either SVO or SOV, with a much smaller but still significant portion using VSO word order." So actually prefix *is* more of an oddball than infix, and even less common than postfix. – Jon Purdy Dec 15 '10 at 21:38
  • SOV... I've always had an affinity for FORTH. And Japanese. – Barry Brown Dec 16 '10 at 00:09
  • @Jon Purdy: I am not sure, what you are saying. The phrase in prefix-notation reads as `not(realize(many(programmers), that(actually(and(is(prefix_notation, the_norm), is(infix, the_oddball))))))`, assuming `actually` spans the whole complementizer (which I didn't consider first). Now what I would say, using prefix notation for unary (which can't be *between* one operand) and infix notation for binary operations (what I "claim" to be common) is `not(many(programmers) realize (that(actually((prefix_notation is the_norm) and (infix is the_oddball)))))`. Which is perfect english, no? – back2dos Dec 16 '10 at 11:26
  • @Jon Purdy: I think the argument is relevant, because the concepts of prefix/infix/postfix-notation arose during the formalization of mathematics, which -as we know it now- is entirely based on work of people from an occidental background. I am not judging, which notation is better, I am only pointing out the ethimological origin. Infix notation is the least practical, but bringing naturalal language into this discussion is the only way to explain why it is popular in the first place. And it is certainly suited in a discussion about mere personal preference ;) – back2dos Dec 16 '10 at 11:31
  • @sepp2k: I'd argue that the `method(receiver, arguments)` syntax is the infix syntax. Think of it as a message- the `method` is part of the message as much as the `arguments`, but the `receiver` is the target. – DeadMG Nov 24 '11 at 10:55
  • _After all, just about every language uses prefix notation for function/method calls_. Not a good example, because in the case of an arbitrary function acting on multiple parameters, there's really no other natural way of doing it (apart from putting the function last). – user1071847 Oct 04 '18 at 14:27
7

I like prefix for function-like things, infix for operator-like things, postfix for property-like things, and mixfix for control-flow like things:

// prefix:
abs(-3)
sin(PI)

// infix:
1 + 2
4 / 5

// postfix:
list size
employee name

// mixfix:
if a then b else c // (where if/then/else is the mixfix function)

What I don't like is languages that don't let me express things the way that reads most naturally to me. I don't like:

// lisp, have to do prefix for everything:
(+ 1 2)
(if a b c)
(size list)

// forth, have to do postfix for everything:
1 2 +
a b c if
1 + 2
4 / 5
munificent
  • 2,029
  • 13
  • 11
  • 2
    Depending on which Lisp you use, you may not need to use prefix for everything. There are infix macro packages available for Common Lisp. – Larry Coleman Dec 15 '10 at 19:33
  • That's true in theory, but in practice Lispers seem to always go prefix. – munificent Dec 20 '10 at 23:55
  • Prefix: operator is on the left, args on the right. Postfix: operator is on the right, args are on the left. So I think your property-like things example is incorrect. Forth example is good though. – Adobe Sep 09 '16 at 08:35
  • In the postfix examples, "size" and "name" are the operations being performed and "list" and "employee" are the arguments. – munificent Sep 09 '16 at 14:32
3

Prefix, simply because operator precedence is explicit.

FYI, Longer calculations (really, any chain of operations) in Clojure can be broken out using the -> and ->> macros. e.g.:

(-> (get-some-value)
  inc
  (* 2)
  (max 50))

is the equivalent of:

(max (* (inc (get-some-value)) 2) 50)

While the -> macro prepends prior results to the arguments of the next expression, ->> appends them. This is typically very handy when used with functions that expect collections and seqs:

=> (->> "some string we want to capitalize"
     (partition-by #{\space})
     (mapcat #(cons (Character/toUpperCase (first %)) (rest %)))
     (apply str))
"Some String We Want To Capitalize"

Providing facilities for easily composing simpler operations into compound ones like this is one of Clojure's big advantages. For additional reading, check out fogus' post on the -> macro, and then his later post on the topic of "properly thrushy" thrush combinators in Clojure.

cemerick
  • 131
  • 2
2

Of those two, prefix (postfix could be used the same way, but the only languages I know of that use that are PS and Forth).

  1. It removes the need for any kind of operator precedence and left/right associativity. Both in the sense that you don't have to think about it, and in the sense that the language implementation is slightly simpler since these forces are pre-resolved.
  2. If applied consistently, the resulting code is very close to a tree, which makes parsing easier or unnecessary (and this allows things like programmatic manipulation of that tree structure).
Inaimathi
  • 4,884
  • 1
  • 26
  • 34
  • 2
    It hardly takes 100 lines to resolve the problems you are describing. Parsing really is not a challenge compared to whatever happens next. Programming language syntax is targeted at programmers, not at parsers. – back2dos Dec 14 '10 at 17:43
  • @back2dos - Agreed, the fact that it's resolved for the implementation is a minor benefit. Why should I (as the programmer) have to figure out what something like `(3 + 6) - 8 × 3 / 24 + 5` actually means? Why not just write `(+ (- (+ 3 6) (/ (* 8 3) 24)) 5)` and remove all doubt, and need for mnemonics? – Inaimathi Dec 14 '10 at 18:06
  • 1
    For the same reason many people stick with QWERTY. It's the predominant way to do it. Speaking for myself, I can process the first expression much faster. I can see why prefix-notation is better, but I'd really have to get used to it. – back2dos Dec 14 '10 at 18:49
  • @back2dos - It's true; there was a non-trivial adjustment period the first time I saw the basic arithmetic operators in CL/Scheme. I think it's worth it for the added consistency and precision. YMMV, as always. – Inaimathi Dec 14 '10 at 21:15
  • You don't even parens in prefix, if you know the arity in ahead. `+ - + 3 6 / * 8 3 24 5` – Ming-Tang Dec 15 '10 at 03:20
  • 1
    @SHiNKiROU: However, if you have parens, you can vary the arity, and I think `(+ a b c d e)` is easier to read and write than, say, `+ + + + a b c d e`. – David Thornley Dec 15 '10 at 20:46
  • GolfScript is also postfix, and I think dc is too. As with PS, it's the natural consequence of being a stack-based language. – Peter Taylor Nov 24 '11 at 12:12
1

Postfix. It is clearly the most commonly used in procedural languages and object oriented languages.

Sequential code is postfix notation:

  do x; do y; do z;

OO code is postfix too:

   a.x.y

Most OO and procedural languages used both these conventions heavily mixed with a bit of infix and maybe some prefix to lighten the cognitive load an increase pattern recognition.

Even functional languages use postfix like format commonly:

   let x = g r in
   let y = f x in
   ..

as a way to make the less comprehensible prefix version:

  let y = f (g r) in

easier to read by factorisation (please imagine a longer more nasty chain of applications:)

Yttrill
  • 727
  • 5
  • 10
1

It depends,

binary operators in which order is important (asymmetric) benefit from infix notation as it is easier to distinguish which way round the operator will be evaluated e.g.

x.Operation(y); //so x is doing "Operation" to y

compared to

Operation(x,y); //what was the order of arguments again?

symmetric operators this is less of an issue, and indeed can sometimes by expanded to be n-ary operators with pre or post fix notation when associative e.g.

sum(1,2,3,4,5);

for pre-fix vs post-fix I prefer prefix as like yoda, you talk, with post-fix

last of all here is what dijstra had to say on the subject in essence he favoured infix for associative operations

jk.
  • 10,216
  • 1
  • 33
  • 43
  • 1
    Love the djistra essay, in his original hand. A real gem, thank you. Personally love working with postfix as implemented in the R package magrittr. – Tony Cronin May 19 '18 at 17:42
1

I vastly prefer to have prefix when I'm reading code.

But infix when thinking about code.

Paul Nathan
  • 8,560
  • 1
  • 33
  • 41