How do I achive the function of Continue using Catch and Throw?

Question

Procedural programming is considered a bad practice in writing Mathematica code. But for education's sake, is there any way I can do Continue using Catch and Throw?

According to WRI's documentation, the function of Break and Continue both can be achieved by using Catch and Throw. For the former one, an example is given: Catch[For[i = 1, i <= 10, i++, If[i > 2, Throw[Null]]]]; i is equivalent to For[i = 1, i <= 10, i++, If[i > 2, Break[]]]; i. For the latter, however, no example could be found. I googled for that, it seems no one asked the question. And I suspect that theoretically it can't even be done. Throw lets you quit a loop, how could it be used to jump to somewhere else in the loop as Continue does?

Answer 1

If you wrap the body of the loop with Catch, then any Throw will act as Continue:

r = 0;
Do[Catch[
   If[EvenQ[i], Throw[Null]];
   r += i
   ], {i, 10}];
r
(* Out: 25 *)

(Example taken from the documentation for Continue.)

Answer 2

This is not an answer, but an extended comment.

I don't think procedural programming in Mathematica is always to be avoided. In particular, consider the following procedural code, a minor variation of the example given for the use of Continue.

r = 0;
Do[
  If[i > 8,
    Break[],
    If[EvenQ[i], Continue[], r += i]],
  {i, 10}];
r

16

Now I write equivalent code with Catch and Throw

r = 0;
Catch[
  Do[
    Catch[
      If[i > 8,
        Throw[Null, 2],
        If[EvenQ[i], Throw[Null, 1]]; r += i],
      1],
    {i, 10}],
  2];
r

And here is the functional version based on the code proposed by J.M. and Mr.Wizard.

Catch[
  Fold[
    Catch[
      If[#2 > 8,
        Throw[#1, 2],
        If[EvenQ[#2], Throw[#1, 1], #1 + #2]], 1] &,
    Range[0, 10]],
  2]

I assert that the first example above has the great virtue of being both concise and clear, which means it is likely to be written without coding errors. Because of this and despite being tainted by procedualism, I think the first example has the best code of the three.

Answer 3

I feel a bit uneasy about posting tangential commentary as answers but since this is too long for Comments here are my thoughts on m_goldberg's post.

I absolutely agree that procedural coding has its place in Mathematica. Nevertheless I feel that the example given is misleading. First a Do loop is already a level of abstraction above For and it is used quite often by experienced users. (It is not representative of procedural code that people typically argue against.) Second Continue[] is quite pointless in this example; one would instead just write:

r = 0;

Do[If[i > 8, Break[], If[OddQ[i], r += i]], {i, 10}]

r

The Break condition itself is also not really valid as it depends solely on the Do iterator which is never directly manipulated. A more realistic example would be a condition on r, e.g.

r = 0;

Do[If[r > 5, Break[], If[OddQ[i], r += i]], {i, 10}]

r    (* 9 *)

This could be written with NestWhile in several ways:

NestWhile[If[OddQ[++i], # + i, #] &, i = 0, # <= 5 &]

NestWhile[# + i*Boole@OddQ[i++] &, i = 0, # <= 5 &]

NestWhile[# + i*Mod[i++, 2] &, i = 0, # <= 5 &]

I do not feel that the Do/Break code is objectively clearer here.

Of course this whole example is still contrived and I one could just write Tr @ Range[1, 8, 2] or Sum[i, {i, 1, 8, 2}] in actuality.

I know it is difficult to contrive an example that is simple enough without being too simple and I do not mean to attack a straw man, but examples should still actually exemplify what they purport to if at all possible, and I feel that this one does not.