Using a "pseudo operator" to distinguish simple repetition from general for loops

I would like to know other people's opinion on the following style of writing a for loop:

for (int rep = numberOfReps; rep --> 0 ;) {
   // do something that you simply want to repeat numberOfReps times
}

The reason why I invented this style is to distinguish it from the more general case of for loops. I only use this when I need to simply repeat something numberOfReps times and the body of the loop does not use the values of rep and numberofReps in any way.

As far as I know, standard Java for example doesn't have a simple way of saying "just repeat this N times", and that's why I came up with this. I'd even go as far as saying that the body of the loop must not continue or break, unless explicitly documented at the top of the for loop, because as I said the whole purpose is to make the code easier to understand by coming up with a distinct style to express simple repetitions.

The idea is that if what you're doing is not simple (dependency on value of an inreasing/decreasing index, breaks, continues, etc), then use the standard for loop. If what you are doing is simple repetition, on the other hand, then this distinct style communicates that "fact" (once you know the purpose of the style, of course).

I said "fact" because the style can be abused, of course. I'm operating under the assumption that you have competent programmers whose objective is to make their code easier to understand, not harder.

A comment was made that allude to the principle that for should only be used for simple iteration, and while should be used otherwise (e.g. if the loop variables are modified in the body).

If that's the case, then I'm merely extending that principle to say that if it's even simpler than your simple for loops (i.e. you don't even care about the iteration index, or whether it's increasing or decreasing, etc, you just want to repeat doing something N times), then use the winking arrow for loop const开发者_运维百科ruct instead.

What a coincidence, Josh Bloch just tweeted the following:

  Goes-to Considered Harmful:

  public static void main(String[] a) {
    int i = 10;
    while (i --> 0) /* i goes-to 0 */ {
      System.out.println(i);
    }
  }

Unfortunately no explanation was given, but it seems that at least this pseudo operator has a name. It has also been discussed before on SO: What is the name of this operator: “-->”?

You have the language-agnostic tag, but this question isn't really language agnostic. That pattern would be fine if there wasn't already a well established idiom for doing something n times in your language.

You go on to mention Java, whicha already has a well-established idiom for doing something n times:

for (int i = 0; i < numberOfReps; i++) {
   // do something that you simply want to repeat numberOfReps times
}

While your pattern works just as well, it's confusing to others. When I first saw it my thoughts were:

1. What's that weird arrow?
2. Why is that line winking at me?

Unless you develop a pattern that has a significant advantage over the standard idiom, it's best to stick with the standard so your fellow coders don't end up scratching their heads.

Nearly every language these days has lambda, so you can write a function like

nTimes(n, body)

that takes an int and a lambda, and more directly communicate intent. In F#, for example

let nTimes(n,f) =
    for i in 1..n do f()

nTimes(3, fun() -> printfn "Hello")    

or if you prefer extension methods

type System.Int32 with
    member this.Times(f) =        
        for i in 1..this do f()

(3).Times(fun() -> printfn "Hello")