Data commit

Task/Loops-Wrong-ranges/00-META.yaml

@@ -0,0 +1,5 @@
+---
+category:
+- Loop modifiers
+from: http://rosettacode.org/wiki/Loops/Wrong_ranges
+note: Iteration

Task/Loops-Wrong-ranges/00-TASK.txt

@@ -0,0 +1,45 @@
+Some languages have syntax or function(s) to generate a range of numeric values from a start value, a stop value, and an increment.
+
+The purpose of this task is to select the range syntax/function that would generate at least two increasing numbers when given a stop value more than the start value and a positive increment of less than half the difference.   You are then to use that ''same'' syntax/function but with different parameters; and show, here, what would happen.
+
+Use these values if possible:
+::::: {| class="wikitable"
+!start ||stop ||increment ||Comment
+|-
+| -2||2||1||Normal
+|-
+| -2||2||0||Zero increment
+|-
+| -2||2||-1||Increments away from stop value
+|-
+| -2||2||10||First increment is beyond stop value
+|-
+|2||-2||1||Start more than stop: positive increment
+|-
+|2||2||1||Start equal stop: positive increment
+|-
+|2||2||-1||Start equal stop: negative increment
+|-
+|2||2||0||Start equal stop: zero increment
+|-
+|0||0||0||Start equal stop equal zero: zero increment
+|}
+
+;Related tasks:
+*   [[Loop over multiple arrays simultaneously]]
+*   [[Loops/Break]]
+*   [[Loops/Continue]]
+*   [[Loops/Do-while]]
+*   [[Loops/Downward for]]
+*   [[Loops/For]]
+*   [[Loops/For with a specified step]]
+*   [[Loops/Foreach]]
+*   [[Loops/Increment loop index within loop body]]
+*   [[Loops/Infinite]]
+*   [[Loops/N plus one half]]
+*   [[Loops/Nested]]
+*   [[Loops/While]]
+*   [[Loops/with multiple ranges]]
+*   [[Loops/Wrong ranges]]
+<br><br>
+

Task/Loops-Wrong-ranges/11l/loops-wrong-ranges.11l

@@ -0,0 +1,11 @@
+F displayRange(first, last, step)
+   print(‘(#2, #2, #2):   ’.format(first, last, step), end' ‘’)
+   I step == 0
+      print(‘not allowed.’)
+   E
+      print(Array((first..last).step(step)))
+
+L(f, l, s) [(-2, 2,  1), (-2, 2, 0), (-2, 2, -1),
+            (-2, 2, 10), (2, -2, 1), ( 2, 2,  1),
+            ( 2, 2, -1), (2,  2, 0), ( 0, 0,  0)]
+   displayRange(f, l, s)

Task/Loops-Wrong-ranges/ALGOL-68/loops-wrong-ranges.alg

@@ -0,0 +1,34 @@
+BEGIN
+    # returns the first n elements of the sequences of values specified by start, stop and increment #
+    PROC sequence = ( INT n, start, stop, increment )[]INT:
+         BEGIN
+            [ 1 : n ]INT s;
+            FOR j FROM LWB s TO UPB s DO s[ j ] := 0 OD;
+            INT s pos := LWB s - 1;
+            FOR j FROM start BY increment TO stop WHILE s pos < n DO
+               s[ s pos +:= 1 ] := j
+            OD;
+            s[ LWB s : s pos ]
+         END # sequence # ;
+
+    # tests the sequence procedure #
+    PROC test sequence = ( INT start, stop, increment, STRING legend )VOID:
+         BEGIN
+            []INT s = sequence( 10, start, stop, increment );
+            print( ( legend, ": " ) );
+            FOR i FROM LWB s TO UPB s DO print( ( " ", whole( s[ i ], -4 ) ) ) OD;
+            print( ( newline ) )
+         END # test sequence # ;
+    # task trest cases #
+
+    test sequence( -2,  2,  1, "Normal                                     " );
+    test sequence( -2,  2,  0, "Zero increment                             " );
+    test sequence( -2,  2, -1, "Increments away from stop value            " );
+    test sequence( -2,  2, 10, "First increment is beyond stop value       " );
+    test sequence(  2, -2,  1, "Start more than stop: positive increment   " );
+    test sequence(  2,  2,  1, "Start equal stop: positive increment       " );
+    test sequence(  2,  2, -1, "Start equal stop: negative increment       " );
+    test sequence(  2,  2,  0, "Start equal stop: zero increment           " );
+    test sequence(  0,  0,  0, "Start equal stop equal zero: zero increment" )
+
+END

Task/Loops-Wrong-ranges/ALGOL-W/loops-wrong-ranges.alg

@@ -0,0 +1,41 @@
+begin
+    % sets the first n elements of s to the sequences of values specified by start, stop and increment    %
+    % s( 0 ) is set to the number of elements of s that have been set, in case the sequence ends before n %
+    procedure sequence ( integer array s ( * )
+                       ; integer value n, start, stop, increment
+                       ) ;
+    begin
+        integer sPos;
+        for j := 0 until n do s( j ) := 0;
+        sPos  := 1;
+        for j := start step increment until stop do begin
+            if sPos > n then goto done;
+               s( sPos ) := j;
+               s( 0    ) := s( 0 ) + 1;
+               sPos      := sPos + 1;
+       end for_j ;
+done:
+    end sequence ;
+    % tests the sequence procedure %
+    procedure testSequence( integer    value start, stop, increment
+                          ; string(48) value legend
+                          ) ;
+    begin
+        integer array s ( 0 :: 10 );
+        sequence( s, 10, start, stop, increment );
+        s_w := 0; % set output formating %
+        i_w := 4;
+        write( legend, ": " );
+        for i := 1 until s( 0 ) do writeon( s( i ) )
+    end testSequence ;
+    % task trest cases %
+    testSequence( -2,  2,  1, "Normal"                                      );
+    testSequence( -2,  2,  0, "Zero increment"                              );
+    testSequence( -2,  2, -1, "Increments away from stop value"             );
+    testSequence( -2,  2, 10, "First increment is beyond stop value"        );
+    testSequence(  2, -2,  1, "Start more than stop: positive increment"    );
+    testSequence(  2,  2,  1, "Start equal stop: positive increment"        );
+    testSequence(  2,  2, -1, "Start equal stop: negative increment"        );
+    testSequence(  2,  2,  0, "Start equal stop: zero increment"            );
+    testSequence(  0,  0,  0, "Start equal stop equal zero: zero increment" )
+end.

Task/Loops-Wrong-ranges/AWK/loops-wrong-ranges.awk

@@ -0,0 +1,24 @@
+# syntax: GAWK -f LOOPS_WRONG_RANGES.AWK
+BEGIN {
+    arr[++n] = "-2, 2, 1,Normal"
+    arr[++n] = "-2, 2, 0,Zero increment"
+    arr[++n] = "-2, 2,-1,Increments away from stop value"
+    arr[++n] = "-2, 2,10,First increment is beyond stop value"
+    arr[++n] = " 2,-2, 1,Start more than stop: positive increment"
+    arr[++n] = " 2, 2, 1,Start equal stop: positive increment"
+    arr[++n] = " 2, 2,-1,Start equal stop: negative increment"
+    arr[++n] = " 2, 2, 0,Start equal stop: zero increment"
+    arr[++n] = " 0, 0, 0,Start equal stop equal zero: zero increment"
+    print("start,stop,increment,comment")
+    for (i=1; i<=n; i++) {
+      split(arr[i],A,",")
+      printf("%-52s : ",arr[i])
+      count = 0
+      for (j=A[1]; j<=A[2] && count<10; j+=A[3]) {
+        printf("%d ",j)
+        count++
+      }
+      printf("\n")
+    }
+    exit(0)
+}

Task/Loops-Wrong-ranges/Ada/loops-wrong-ranges.ada

@@ -0,0 +1,51 @@
+with Ada.Text_IO; use Ada.Text_IO;
+with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
+with Ada.Text_IO.Unbounded_IO; use Ada.Text_IO.Unbounded_IO;
+
+procedure Main is
+   procedure print_range(start : integer; stop : integer; step : integer) is
+      Num : Integer := start;
+   begin
+      Put("Range(" & start'Image & ", " & stop'image &
+            ", " & step'image & ") => ");
+      if stop < start then
+         Put_Line("Error: stop must be no less than start!");
+      elsif step not in positive then
+         Put_Line("Error: increment must be greater than 0!");
+      elsif start = stop then
+         Put_Line(start'image);
+      else
+         while num <= stop loop
+            Put(num'Image);
+            num := num + step;
+         end loop;
+         New_Line;
+      end if;
+   end print_range;
+
+   type test_record is record
+      start   : integer;
+      stop    : integer;
+      step    : integer;
+      comment : unbounded_string := null_unbounded_string;
+   end record;
+
+   tests : array(1..9) of test_record :=
+     ( 1 => (-2, 2, 1, To_Unbounded_String("Normal")),
+       2 => (-2, 2, 0, To_Unbounded_String("Zero increment")),
+       3 => (-2, 2, -1, To_Unbounded_String("Increments away from stop value")),
+       4 => (-2, 2, 10, To_Unbounded_String("First increment is beyond stop value")),
+       5 => (2, -1, 1, To_Unbounded_String("Start more than stop: positive increment")),
+       6 => (2, 2, 1, To_Unbounded_String("Start equal stop: positive increment")),
+       7 => (2, 2, -1, To_Unbounded_String("Start equal stop: negative increment")),
+       8 => (2, 2, 0, To_Unbounded_String("Start equal stop: zero increment")),
+       9 => (0, 0, 0, To_Unbounded_String("Start equal stop equal zero: zero increment")));
+
+
+begin
+   for test of tests loop
+      Put(Test.Comment); Put(" : ");
+      print_range(test.start, test.stop, test.step);
+      New_line;
+   end loop;
+end Main;

Task/Loops-Wrong-ranges/Applesoft-BASIC/loops-wrong-ranges.basic

@@ -0,0 +1,24 @@
+0 LIMIT = 10 :MAX=1E37
+10 DATA-2,2,1,NORMAL
+20 DATA-2,2,0,ZERO INCREMENT
+30 DATA-2,2,-1,INCREMENTS AWAY FROM STOP VALUE
+40 DATA-2,2,10,FIRST INCREMENT IS BEYOND STOP VALUE
+50 DATA2,-2,1,"START MORE THAN STOP: POSITIVE INCREMENT
+60 DATA2,2,1,"START EQUAL STOP: POSITIVE INCREMENT
+70 DATA2,2,-1,"START EQUAL STOP: NEGATIVE INCREMENT
+80 DATA2,2,0,"START EQUAL STOP: ZERO INCREMENT
+90 DATA0,0,0,"START EQUAL STOP EQUAL ZERO: ZERO INCREMENT
+100 FOR I = 1 TO 9
+110     READ START,FINISH,INCR,COMMENT$
+120     PRINT CHR$(13)COMMENT$
+130     LAST = FINISH
+140 REM D = SGN(FINISH - START)
+150 REM IF D AND NOT (D = SGN(INCR)) THEN LAST = SGN(INCR)*MAX
+160     PRINT TAB(5)CHR$(91)" "MID$(" ",(START<0)+1)START" TO "MID$(" ",(FINISH<0)+1)FINISH" STEP "MID$(" ",(INCR<0)+1)INCR" ]    ";
+170     COUNT = 0
+180     PRINT MID$(" ",(START<0)+1);
+190     FOR J = START TO LAST STEP INCR
+200         PRINT MID$(" ",(COUNT=0)+1)J;
+210         IF COUNT < LIMIT THEN COUNT = COUNT + 1 : NEXT J
+220     IF COUNT = LIMIT THEN PRINT " ... ";:if ABS(LAST) = MAX THEN PRINT MID$("-",SGN(LAST)+2,1)"INFINITY";
+230 NEXT I

Task/Loops-Wrong-ranges/Arturo/loops-wrong-ranges.arturo

@@ -0,0 +1,19 @@
+print "start   stop    increment"
+
+loop @[
+    0-2 2   1
+    0-2 2   0
+    0-2 2   0-1
+    0-2 2   10
+      2 0-2 1
+      2 2   1
+      2 2   0-1
+      2 2   0
+      0 0   0
+] [start stop increment] ->
+    print [
+        pad ~"|start|" 2 pad ~"|stop|" 7 pad ~"|increment|" 7
+        pad "->" 9
+        try? -> @range.step: increment start stop
+        else -> "Error"
+    ]

Task/Loops-Wrong-ranges/BASIC256/loops-wrong-ranges.basic

@@ -0,0 +1,27 @@
+arraybase 1
+dim start(9) : dim fin(9) : dim inc(9) : dim cmt$(9)
+start[1] = -2 : fin[1] =  2 : inc[1] =  1 : cmt$[1] = "Normal"
+start[2] = -2 : fin[2] =  2 : inc[2] =  0 : cmt$[2] = "Zero increment"
+start[3] = -2 : fin[3] =  2 : inc[3] = -1 : cmt$[3] = "Increments away from stop value"
+start[4] = -2 : fin[4] =  2 : inc[4] = 10 : cmt$[4] = "First increment is beyond stop value"
+start[5] =  2 : fin[5] = -2 : inc[5] =  1 : cmt$[5] = "Start more than stop: positive increment"
+start[6] =  2 : fin[6] =  2 : inc[6] =  1 : cmt$[6] = "Start equal stop: positive increment"
+start[7] =  2 : fin[7] =  2 : inc[7] = -1 : cmt$[7] = "Start equal stop: negative increment"
+start[8] =  2 : fin[8] =  2 : inc[8] =  0 : cmt$[8] = "Start equal stop: zero increment"
+start[9] =  0 : fin[9] =  0 : inc[9] =  0 : cmt$[9] = "Start equal stop equal zero: zero increment"
+
+for i = 1 to 9
+    contar = 0
+    print cmt$[i]
+    print "  Bucle de "; start[i]; " a "; fin[i]; " en incrementos de "; inc[i]
+    for vr = start[i] to fin[i] step inc[i]
+        print "        Índice del bucle = "; vr
+        contar = contar + 1
+        if contar = 10 then
+            print "        Saliendo de un bucle infinito"
+            exit for
+        endif
+    next vr
+    print "  Bucle terminado" & chr(10) & chr(10)
+next i
+end

Task/Loops-Wrong-ranges/C-sharp/loops-wrong-ranges-1.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+
+static class Program
+{
+    static void Main()
+    {
+        Example(-2, 2, 1, "Normal");
+        Example(-2, 2, 0, "Zero increment");
+        Example(-2, 2, -1, "Increments away from stop value");
+        Example(-2, 2, 10, "First increment is beyond stop value");
+        Example(2, -2, 1, "Start more than stop: positive increment");
+        Example(2, 2, 1, "Start equal stop: positive increment");
+        Example(2, 2, -1, "Start equal stop: negative increment");
+        Example(2, 2, 0, "Start equal stop: zero increment");
+        Example(0, 0, 0, "Start equal stop equal zero: zero increment");
+    }
+
+    static IEnumerable<int> Range(int start, int stop, int increment)
+    {
+        // To replicate the (arguably more correct) behavior of VB.NET:
+        //for (int i = start; increment >= 0 ? i <= stop : stop <= i; i += increment)
+
+        // Decompiling the IL emitted by the VB compiler (uses shifting right by 31 as the signum function and bitwise xor in place of the conditional expression):
+        //for (int i = start; ((increment >> 31) ^ i) <= ((increment >> 31) ^ stop); i += increment)
+
+        // "Naïve" translation.
+        for (int i = start; i <= stop; i += increment)
+            yield return i;
+    }
+
+    static void Example(int start, int stop, int increment, string comment)
+    {
+        // Add a space, pad to length 50 with hyphens, and add another space.
+        Console.Write((comment + " ").PadRight(50, '-') + " ");
+
+        const int MAX_ITER = 9;
+
+        int iteration = 0;
+        foreach (int i in Range(start, stop, increment))
+        {
+            Console.Write("{0,2} ", i);
+
+            if (++iteration > MAX_ITER) break;
+        }
+
+        Console.WriteLine();
+    }
+}

Task/Loops-Wrong-ranges/C-sharp/loops-wrong-ranges-2.cs

@@ -0,0 +1,38 @@
+using System;
+
+static class Program {
+    struct S {
+        public int Start, Stop, Incr;
+        public string Comment;
+    }
+
+    static readonly S[] examples = {
+        new S{Start=-2, Stop=2, Incr=1, Comment="Normal"},
+        new S{Start=-2, Stop=2, Incr=0, Comment="Zero increment"},
+        new S{Start=-2, Stop=2, Incr=-1, Comment="Increments away from stop value"},
+        new S{Start=-2, Stop=2, Incr=10, Comment="First increment is beyond stop value"},
+        new S{Start=2, Stop=-2, Incr=1, Comment="Start more than stop: positive increment"},
+        new S{Start=2, Stop=2, Incr=1, Comment="Start equal stop: positive increment"},
+        new S{Start=2, Stop=2, Incr=-1, Comment="Start equal stop: negative increment"},
+        new S{Start=2, Stop=2, Incr=0, Comment="Start equal stop: zero increment"},
+        new S{Start=0, Stop=0, Incr=0, Comment="Start equal stop equal zero: zero increment"}
+    };
+
+    static int Main() {
+        const int limit = 10;
+        bool empty;
+        for (int i = 0; i < 9; ++i) {
+            S s = examples[i];
+            Console.Write("{0}\n", s.Comment);
+            Console.Write("Range({0:d}, {1:d}, {2:d}) -> [", s.Start, s.Stop, s.Incr);
+            empty = true;
+            for (int j = s.Start, c = 0; j <= s.Stop && c < limit; j += s.Incr, ++c) {
+                Console.Write("{0:d} ", j);
+                empty = false;
+            }
+            if (!empty) Console.Write("\b");
+            Console.Write("]\n\n");
+        }
+        return 0;
+    }
+}

Task/Loops-Wrong-ranges/C/loops-wrong-ranges.c

@@ -0,0 +1,43 @@
+#include <stdio.h>
+
+#define TRUE 1
+#define FALSE 0
+
+typedef int bool;
+
+typedef struct {
+    int start, stop, incr;
+    const char *comment;
+} S;
+
+S examples[9] = {
+    {-2, 2, 1, "Normal"},
+    {-2, 2, 0, "Zero increment"},
+    {-2, 2, -1, "Increments away from stop value"},
+    {-2, 2, 10, "First increment is beyond stop value"},
+    {2, -2, 1, "Start more than stop: positive increment"},
+    {2, 2, 1, "Start equal stop: positive increment"},
+    {2, 2, -1, "Start equal stop: negative increment"},
+    {2, 2, 0, "Start equal stop: zero increment"},
+    {0, 0, 0, "Start equal stop equal zero: zero increment"}
+};
+
+int main() {
+    int i, j, c;
+    bool empty;
+    S s;
+    const int limit = 10;
+    for (i = 0; i < 9; ++i) {
+        s = examples[i];
+        printf("%s\n", s.comment);
+        printf("Range(%d, %d, %d) -> [", s.start, s.stop, s.incr);
+        empty = TRUE;
+        for (j = s.start, c = 0; j <= s.stop && c < limit; j += s.incr, ++c) {
+            printf("%d ", j);
+            empty = FALSE;
+        }
+        if (!empty) printf("\b");
+        printf("]\n\n");
+    }
+    return 0;
+}

Task/Loops-Wrong-ranges/Chipmunk-Basic/loops-wrong-ranges.basic

@@ -0,0 +1,21 @@
+100 cls
+110 for i = 1 to 9
+120  contar = 0
+130  read start,fin,inc,cmt$
+140  print cmt$
+150  print "  Bucle de ";start;"a ";fin;" en incrementos de ";inc
+160  for vr = start to fin step inc
+170   print "        Indice del bucle = ";vr
+180   contar = contar+1
+190   if contar = 10 then
+200    print "        Saliendo de un bucle infinito"
+210    goto 240
+220   endif
+230  next vr
+240  print "  Bucle terminado" : print : print
+250 next i
+260 end
+270 data -2,2,1,"Normal",-2,2,0,"Zero increment",-2,2,-1,"Increments away from stop value"
+280 data -2,2,10,"First increment is beyond stop value",2,-2,1,"Start more than stop: positive increment"
+290 data 2,2,1,"Start equal stop: positive increment",2,2,-1,"Start equal stop: negative increment"
+300 data 2,2,0,"Start equal stop: zero increment",0,0,0,"Start equal stop equal zero: zero increment"

Task/Loops-Wrong-ranges/Common-Lisp/loops-wrong-ranges.lisp

@@ -0,0 +1,18 @@
+(dolist (lst '((-2  2  1 "Normal")	  ; Iterate the parameters list `start' `stop' `increment' and `comment'
+	       (-2  2  0 "Zero increment")
+	       (-2  2 -1 "Increments away from stop value")
+	       (-2  2 10 "First increment is beyond stop value")
+	       ( 2 -2  1 "Start more than stop: positive increment")
+	       ( 2  2  1 "Start equal stop: positive increment")
+	       ( 2  2 -1 "Start equal stop: negative increment")
+	       ( 2  2  0 "Start equal stop: zero increment")
+	       ( 0  0  0 "Start equal stop equal zero: zero increment")))
+  (do ((i (car lst) (incf i (caddr lst))) ; Initialize `start' and set `increment'
+       (result ())			  ; Initialize the result list
+       (loop-max 0 (incf loop-max)))	  ; Initialize a loop limit
+      ((or (> i (cadr lst))		  ; Break condition to `stop'
+	   (> loop-max 10))		  ; Break condition to loop limit
+       (format t "~&~44a: ~{~3d ~}"	  ; Finally print
+	       (cadddr lst)		  ; The `comment'
+	       (reverse result)))	  ; The in(de)creased numbers into result
+    (push i result)))			  ; Add the number to result

Task/Loops-Wrong-ranges/Delphi/loops-wrong-ranges-1.delphi

@@ -0,0 +1,56 @@
+program Wrong_ranges;
+
+{$APPTYPE CONSOLE}
+
+uses
+  System.SysUtils;
+
+procedure Example(start, stop, Increment: Integer; comment: string);
+var
+  MAX_ITER, iteration, i: Integer;
+begin
+  Write((comment + ' ').PadRight(50, '-') + ' ');
+  MAX_ITER := 9;
+  iteration := 0;
+
+  if Increment = 1 then
+  begin
+    for i := start to stop do
+    begin
+      Write(i: 2, ' ');
+      inc(iteration);
+      if iteration >= MAX_ITER then
+        Break;
+    end;
+    Writeln;
+    exit;
+  end;
+
+  if Increment = -1 then
+  begin
+    for i := start downto stop do
+    begin
+      Write(i: 2, ' ');
+      inc(iteration);
+      if iteration >= MAX_ITER then
+        Break;
+    end;
+    Writeln;
+    exit;
+  end;
+
+  Writeln('Not supported');
+end;
+
+begin
+  Example(-2, 2, 1, 'Normal');
+  Example(-2, 2, 0, 'Zero increment');
+  Example(-2, 2, -1, 'Increments away from stop value');
+  Example(-2, 2, 10, 'First increment is beyond stop value');
+  Example(2, -2, 1, 'Start more than stop: positive increment');
+  Example(2, 2, 1, 'Start equal stop: positive increment');
+  Example(2, 2, -1, 'Start equal stop: negative increment');
+  Example(2, 2, 0, 'Start equal stop: zero increment');
+  Example(0, 0, 0, 'Start equal stop equal zero: zero increment');
+  Readln;
+end.

Task/Loops-Wrong-ranges/Delphi/loops-wrong-ranges-2.delphi

@@ -0,0 +1,84 @@
+program Wrong_rangesEnumerator;
+
+{$APPTYPE CONSOLE}
+
+uses
+  System.SysUtils;
+
+type
+  TRange = record
+  private
+    Fincrement: Integer;
+    FIndex: Integer;
+    FStart, FStop, FValue: Integer;
+    function GetCurrent: Integer; inline;
+  public
+    constructor Create(start, stop, Increment: Integer);
+    function MoveNext: Boolean; inline;
+    function GetEnumerator: TRange;
+    property Current: Integer read GetCurrent;
+  end;
+
+{ TEnumerator<T> }
+
+constructor TRange.Create(start, stop, Increment: Integer);
+begin
+  FStart := start;
+  FStop := stop;
+  Fincrement := Increment;
+  FValue := start - Increment;
+end;
+
+function TRange.GetCurrent: Integer;
+begin
+  Result := FValue;
+end;
+
+function TRange.GetEnumerator: TRange;
+begin
+  Result := self;
+end;
+
+function TRange.MoveNext: Boolean;
+begin
+  FValue := FValue + Fincrement;
+  if (Fincrement > 0) and (FValue > FStop) then
+    exit(False);
+
+  if (Fincrement < 0) and (FValue < FStop) then
+    exit(False);
+
+  Result := True;
+end;
+
+procedure Example(start, stop, Increment: Integer; comment: string);
+var
+  MAX_ITER, iteration, i, e: Integer;
+begin
+  Write((comment + ' ').PadRight(50, '-') + ' ');
+  MAX_ITER := 9;
+  iteration := 0;
+
+  for e in TRange.Create(start, stop, Increment) do
+  begin
+    Write(e: 2, ' ');
+    inc(iteration);
+    if iteration >= MAX_ITER then
+      Break;
+  end;
+
+  Writeln;
+end;
+
+begin
+  Example(-2, 2, 1, 'Normal');
+  Example(-2, 2, 0, 'Zero increment');
+  Example(-2, 2, -1, 'Increments away from stop value');
+  Example(-2, 2, 10, 'First increment is beyond stop value');
+  Example(2, -2, 1, 'Start more than stop: positive increment');
+  Example(2, 2, 1, 'Start equal stop: positive increment');
+  Example(2, 2, -1, 'Start equal stop: negative increment');
+  Example(2, 2, 0, 'Start equal stop: zero increment');
+  Example(0, 0, 0, 'Start equal stop equal zero: zero increment');
+  Readln;
+end.

Task/Loops-Wrong-ranges/Eiffel/loops-wrong-ranges.e

@@ -0,0 +1,13 @@
+example
+		-- Loops/Wrong ranges
+	do
+		⟳ ic:(-2 |..| 2) ¦ 				do_nothing ⟲ --  2 	2 	 1 	Normal
+		⟳ ic:(-2 |..| 2).new_cursor + 0 ¦ 		do_nothing ⟲ -- -2 	2 	 0 	Zero increment
+		⟳ ic:(-2 |..| 2).new_cursor - 1 ¦ 		do_nothing ⟲ -- -2 	2 	-1 	Increments away from stop value
+		⟳ ic:(-2 |..| 2).new_cursor + 10 ¦ 		do_nothing ⟲ -- -2 	2 	10 	First increment is beyond stop value
+		⟳ ic:(-2 |..| 2).new_cursor.reversed ¦ 		do_nothing ⟲ --  2 	-2 	 1 	Start more than stop: positive increment
+		⟳ ic:(2 |..| 2) ¦ 				do_nothing ⟲ --  2 	2 	 1 	Start equal stop: positive increment
+		⟳ ic:(2 |..| 2).new_cursor - 1 ¦ 		do_nothing ⟲ --  2 	2 	-1 	Start equal stop: negative increment
+		⟳ ic:(2 |..| 2).new_cursor + 0 ¦ 		do_nothing ⟲ --  2 	2 	 0 	Start equal stop: zero increment
+		⟳ ic:(0 |..| 0).new_cursor + 0 ¦ 		do_nothing ⟲ --  0 	0 	 0 	Start equal stop equal zero: zero increment
+	end

Task/Loops-Wrong-ranges/Factor/loops-wrong-ranges.factor

@@ -0,0 +1,16 @@
+USING: continuations formatting io kernel math.ranges
+prettyprint sequences ;
+
+: try-range ( from length step -- )
+    [ <range> { } like . ]
+    [ 4drop "Exception: divide by zero." print ] recover ;
+
+{
+    { -2 2 1 } { 2 2 0 } { -2 2 -1 } { -2 2 10 } { 2 -2 1 }
+    { 2 2 1 } { 2 2 -1 } { 2 2 0 } { 0 0 0 }
+}
+[
+    first3
+    [ "%2d %2d %2d <range>  =>  " printf ]
+    [ try-range ] 3bi
+] each

Task/Loops-Wrong-ranges/Fermat/loops-wrong-ranges.fermat

@@ -0,0 +1,9 @@
+for a = -2 to  2 by  1 do !(a,' '); od;
+for a = -2 to  2 by  0 do !(a,' '); od;
+for a = -2 to  2 by -1 do !(a,' '); od;
+for a = -2 to  2 by 10 do !(a,' '); od;
+for a =  2 to -2 by  1 do !(a,' '); od;
+for a =  2 to  2 by  1 do !(a,' '); od;
+for a =  2 to  2 by -1 do !(a,' '); od;
+for a =  2 to  2 by  0 do !(a,' '); od;
+for a =  0 to  0 by  0 do !(a,' '); od;

Task/Loops-Wrong-ranges/Forth/loops-wrong-ranges-1.fth

@@ -0,0 +1,14 @@
+: test-seq  ( start stop inc -- )
+  cr rot dup ." start: " 2 .r
+  rot dup ."  stop: " 2 .r
+  rot dup ."  inc: " 2 .r ."  | "
+  -rot swap do i . dup +loop drop ;
+-2  2  1 test-seq
+-2  2  0 test-seq
+-2  2 -1 test-seq
+-2  2 10 test-seq
+ 2 -2  1 test-seq
+ 2  2  1 test-seq
+ 2  2 -1 test-seq
+ 2  2  0 test-seq
+ 0  0  0 test-seq

Task/Loops-Wrong-ranges/Forth/loops-wrong-ranges-2.fth

@@ -0,0 +1,14 @@
+: test-seq  ( start stop inc -- )
+  cr rot dup ." start: " 2 .r
+  rot dup ."  stop: " 2 .r
+  rot dup ."  inc: " 2 .r ."  | "
+  -rot swap ?do i . dup +loop drop ;
+-2  2  1 test-seq
+-2  2  0 test-seq
+-2  2 -1 test-seq
+-2  2 10 test-seq
+ 2 -2  1 test-seq
+ 2  2  1 test-seq
+ 2  2 -1 test-seq
+ 2  2  0 test-seq
+ 0  0  0 test-seq

Task/Loops-Wrong-ranges/FreeBASIC/loops-wrong-ranges.basic

@@ -0,0 +1,24 @@
+data -2,2,1,"Normal",-2,2,0,"Zero increment",-2,2,-1,"Increments away from stop value"
+data -2,2,10,"First increment is beyond stop value",2,-2,1,"Start more than stop: positive increment"
+data 2,2,1,"Start equal stop: positive increment",2,2,-1,"Start equal stop: negative increment"
+data 2,2,0,"Start equal stop: zero increment",0,0,0,"Start equal stop equal zero: zero increment"
+
+dim as integer i, start, fin, inc, vr, count
+dim as string cmt
+for i = 1 to 9
+    count = 0
+    read start, fin, inc, cmt
+    print cmt
+    print using "  Looping from ### to ### in increments of ##"; start; fin; inc
+    for vr = start to fin step inc
+        print "        Loop index = ",vr
+        count += 1
+        if count = 10 then
+            print "        Breaking infinite loop"
+            exit for
+        end if
+    next vr
+    print "  Loop finished"
+    print
+    print
+next i

Task/Loops-Wrong-ranges/Go/loops-wrong-ranges.go

@@ -0,0 +1,38 @@
+package main
+
+import "fmt"
+
+type S struct {
+    start, stop, incr int
+    comment          string
+}
+
+var examples = []S{
+    {-2, 2, 1, "Normal"},
+    {-2, 2, 0, "Zero increment"},
+    {-2, 2, -1, "Increments away from stop value"},
+    {-2, 2, 10, "First increment is beyond stop value"},
+    {2, -2, 1, "Start more than stop: positive increment"},
+    {2, 2, 1, "Start equal stop: positive increment"},
+    {2, 2, -1, "Start equal stop: negative increment"},
+    {2, 2, 0, "Start equal stop: zero increment"},
+    {0, 0, 0, "Start equal stop equal zero: zero increment"},
+}
+
+func sequence(s S, limit int) []int {
+    var seq []int
+    for i, c := s.start, 0; i <= s.stop && c < limit; i, c = i+s.incr, c+1 {
+        seq = append(seq, i)
+    }
+    return seq
+}
+
+func main() {
+    const limit = 10
+    for _, ex := range examples {
+        fmt.Println(ex.comment)
+        fmt.Printf("Range(%d, %d, %d) -> ", ex.start, ex.stop, ex.incr)
+        fmt.Println(sequence(ex, limit))
+        fmt.Println()
+    }
+}

Task/Loops-Wrong-ranges/Haskell/loops-wrong-ranges.hs

@@ -0,0 +1,25 @@
+import Data.List
+
+main = putStrLn $ showTable True '|' '-' '+' table
+
+table = [["start","stop","increment","Comment","Code","Result/Analysis"]
+        ,["-2","2","1","Normal","[-2,-1..2] or [-2..2]",show [-2,-1..2]]
+        ,["-2","2","0","Zero increment","[-2,-2..2]","Infinite loop of -2 <=> repeat -2"]
+        ,["-2","2","-1","Increments away from stop value","[-2,-3..2]",show [-2,-3..2]]
+        ,["-2","2","10","First increment is beyond stop value","[-2,8..2]",show [-2,8..2]]
+        ,["2","-2","1","Start more than stop: positive increment","[2,3.. -2]",show [2,3.. -2]]
+        ,["2","2","1","Start equal stop: positive increment","[2,3..2]",show [2,3..2]]
+        ,["2","2","-1","Start equal stop: negative increment","[2,1..2]",show [2,1..2]]
+        ,["2","2","0","Start equal stop: zero increment","[2,2..2]","Infinite loop of 2 <=> repeat 2"]
+        ,["0","0","0","Start equal stop equal zero: zero increment","[0,0..0]", "Infinite loop of 0 <=> repeat 0"]]
+
+showTable::Bool -> Char -> Char -> Char -> [[String]] -> String
+showTable _ _ _ _ [] = []
+showTable header ver hor sep contents = unlines $ hr:(if header then z:hr:zs else intersperse hr zss) ++ [hr]
+   where
+   vss = map (map length) $ contents
+   ms = map maximum $ transpose vss ::[Int]
+   hr = concatMap (\ n -> sep : replicate n hor) ms ++ [sep]
+   top = replicate (length hr) hor
+   bss = map (\ps -> map (flip replicate ' ') $ zipWith (-) ms ps) $ vss
+   zss@(z:zs) = zipWith (\us bs -> (concat $ zipWith (\x y -> (ver:x) ++ y) us bs) ++ [ver]) contents bss

Task/Loops-Wrong-ranges/Huginn/loops-wrong-ranges.huginn

@@ -0,0 +1,35 @@
+import Algorithms as algo;
+
+class Example {
+  _start = none;
+  _stop = none;
+  _step = none;
+  _comment = none;
+}
+
+main() {
+  examples = [
+    Example( -2,  2,  1, "Normal" ),
+    Example(  2,  2,  0, "Start equal stop: zero increment" ),
+    Example(  0,  0,  0, "Start equal stop equal zero: zero increment" ),
+    Example(  2,  2,  1, "Start equal stop: positive increment" ),
+    Example(  2,  2, -1, "Start equal stop: negative increment" ),
+    Example( -2,  2, 10, "First increment is beyond stop value" ),
+    Example( -2,  2,  0, "Zero increment, stop greater than start" ),
+    Example( -2,  2, -1, "Increments away from stop value" ),
+    Example(  2, -2,  1, "Start more than stop: positive increment" )
+  ];
+  for ( ex : examples ) {
+    print(
+      "{}\nRange( {}, {}, {} ) -> ".format(
+        ex._comment, ex._start, ex._stop, ex._step
+      )
+    );
+    r = algo.range( ex._start, ex._stop, ex._step );
+    print(
+      "{}\n\n".format(
+        algo.materialize( algo.slice( r, 22 ), list )
+      )
+    );
+  }
+}

Task/Loops-Wrong-ranges/J/loops-wrong-ranges-1.j

@@ -0,0 +1,4 @@
+genrange=:  {{
+  'start stop increment'=. y
+  start+increment*i.1+<.(stop-start)%increment
+}}

Task/Loops-Wrong-ranges/J/loops-wrong-ranges-2.j

@@ -0,0 +1,20 @@
+   genrange 9 2 _2   NB. valid
+9 7 5 3
+   genrange _2 2 1   NB. valid
+_2 _1 0 1 2
+   genrange _2 2 0   NB. invalid: requires at least an infinity of values
+|domain error: genrange
+   genrange _2 2 _1   NB. projects backwards from _2
+_4 _3 _2
+   genrange _2 2 10   NB. valid
+_2
+   genrange 2 _2 1   NB. projects backwards from 2
+4 3 2
+   genrange 2 2 1   NB. valid (increment is irrelevant)
+2
+   genrange 2 2 _1   NB. valid (increment is irrelevant)
+2
+   genrange 2 2 0   NB. valid (increment is irrelevant)
+2
+   genrange 0 0 0   NB. valid (increment is irrelevant)
+0

Task/Loops-Wrong-ranges/Java/loops-wrong-ranges.java

@@ -0,0 +1,42 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class LoopsWrongRanges {
+
+    public static void main(String[] args) {
+        runTest(new LoopTest(-2, 2, 1, "Normal"));
+        runTest(new LoopTest(-2, 2, 0, "Zero increment"));
+        runTest(new LoopTest(-2, 2, -1, "Increments away from stop value"));
+        runTest(new LoopTest(-2, 2, 10, "First increment is beyond stop value"));
+        runTest(new LoopTest(2, -2, 1, "Start more than stop: positive increment"));
+        runTest(new LoopTest(2, 2, 1, "Start equal stop: positive increment"));
+        runTest(new LoopTest(2, 2, -1, "Start equal stop: negative increment"));
+        runTest(new LoopTest(2, 2, 0, "Start equal stop: zero increment"));
+        runTest(new LoopTest(0, 0, 0, "Start equal stop equal zero: zero increment"));
+    }
+
+    private static void runTest(LoopTest loopTest) {
+        List<Integer> values = new ArrayList<>();
+        for (int i = loopTest.start ; i <= loopTest.stop ; i += loopTest.increment ) {
+            values.add(i);
+            if ( values.size() >= 10 ) {
+                break;
+            }
+        }
+        System.out.printf("%-45s %s%s%n", loopTest.comment, values, values.size()==10 ? " (loops forever)" : "");
+    }
+
+    private static class LoopTest {
+        int start;
+        int stop;
+        int increment;
+        String comment;
+        public LoopTest(int start, int stop, int increment, String comment) {
+            this.start = start;
+            this.stop = stop;
+            this.increment = increment;
+            this.comment = comment;
+        }
+    }
+
+}

Task/Loops-Wrong-ranges/Julia/loops-wrong-ranges.julia

@@ -0,0 +1,9 @@
+collect(-2:1:2)   # → [-2, -1, 0, 1, 2]
+collect(-2:0:2)   # fails
+collect(-2:-1:2)  # → []
+collect(-2:10:2)  # → [-2]
+collect(2:1:-2)   # → []
+collect(2:1:2)    # → [2]
+collect(2:-1:2)   # → [2]
+collect(2:0:2)    # fails
+collect(0:0:0)    # fails

Task/Loops-Wrong-ranges/Kotlin/loops-wrong-ranges.kotlin

@@ -0,0 +1,40 @@
+// Version 1.2.70
+
+class Example(val start: Int, val stop: Int, val incr: Int, val comment: String)
+
+var examples = listOf(
+    Example(-2, 2, 1, "Normal"),
+    Example(-2, 2, 0, "Zero increment"),
+    Example(-2, 2, -1, "Increments away from stop value"),
+    Example(-2, 2, 10, "First increment is beyond stop value"),
+    Example(2, -2, 1, "Start more than stop: positive increment"),
+    Example(2, 2, 1, "Start equal stop: positive increment"),
+    Example(2, 2, -1, "Start equal stop: negative increment"),
+    Example(2, 2, 0, "Start equal stop: zero increment"),
+    Example(0, 0, 0, "Start equal stop equal zero: zero increment")
+)
+
+fun sequence(ex: Example, limit: Int) =
+    if (ex.incr == 0) {
+        List(limit) { ex.start }
+    }
+    else {
+        val res = mutableListOf<Int>()
+        var c = 0
+        var i = ex.start
+        while (i <= ex.stop && c < limit) {
+            res.add(i)
+            i += ex.incr
+            c++
+        }
+        res
+    }
+
+fun main(args: Array<String>) {
+    for (ex in examples) {
+        println(ex.comment)
+        System.out.printf("Range(%d, %d, %d) -> ", ex.start, ex.stop, ex.incr)
+        println(sequence(ex, 10))
+        println()
+    }
+}

Task/Loops-Wrong-ranges/Langur/loops-wrong-ranges.langur

@@ -0,0 +1,30 @@
+val .data = q:block END
+    start     stop     increment     comment
+    -2        2        1             Normal
+    -2        2        0             Zero increment
+    -2        2        -1            Increments away from stop value
+    -2        2        10            First increment is beyond stop value
+    2         -2       1             Start more than stop: positive increment
+    2         2        1             Start equal stop: positive increment
+    2         2        -1            Start equal stop: negative increment
+    2         2        0             Start equal stop: zero increment
+    0         0        0             Start equal stop equal zero: zero increment
+END
+
+var .table = submatches(RE/([^ ]+) +([^ ]+) +([^ ]+) +(.+)\n?/, .data)
+val .f = toNumber
+for .i in 2..len(.table) {
+    .table[.i] = map [.f, .f, .f, _], .table[.i]
+}
+
+for .test in rest(.table) {
+    val .start, .stop, .inc, .comment = .test
+    {
+        val .series = series(.start .. .stop, .inc)
+        catch {
+            writeln $"\.comment;\nERROR: \._err["msg"]:L200(...);\n"
+        } else {
+            writeln $"\.comment;\nresult: \.series;\n"
+        }
+    }
+}

Task/Loops-Wrong-ranges/Lua/loops-wrong-ranges.lua

@@ -0,0 +1,25 @@
+tests = {
+  { -2, 2,  1, "Normal" },
+  {-2,  2,  0, "Zero increment" }, -- 5.4 error
+  {-2,  2, -1, "Increments away from stop value" },
+  {-2,  2, 10, "First increment is beyond stop value" },
+  { 2, -2,  1, "Start more than stop: positive increment" },
+  { 2,  2,  1, "Start equal stop: positive increment" },
+  { 2,  2, -1, "Start equal stop: negative increment" },
+  { 2,  2,  0, "Start equal stop: zero increment" }, -- 5.4 error
+  { 0,  0,  0, "Start equal stop equal zero: zero increment" } -- 5.4 error
+}
+unpack = unpack or table.unpack -- polyfill 5.2 vs 5.3
+for _,test in ipairs(tests) do
+  start,stop,incr,desc = unpack(test)
+  io.write(string.format("%-44s (%2d, %2d, %2d) :  ",desc,start,stop,incr))
+  local sta,err = pcall(function()
+    local n = 0
+    for i = start,stop,incr do
+      io.write(string.format("%2d, ", i))
+      n=n+1 if n>=10 then io.write("...") break end
+    end
+    io.write("\n")
+  end)
+  if err then io.write("RUNTIME ERROR!\n") end
+end

Task/Loops-Wrong-ranges/Maple/loops-wrong-ranges.maple

@@ -0,0 +1,26 @@
+# Normal
+seq(-2..2, 1);
+
+# Zero increment
+seq(-2..2, 0);
+
+# Increments away from stop value
+seq(-2..2, -1);
+
+# First increment is beyond stop value
+seq(-2..2, 10);
+
+# Start more than stop: positive increment
+seq(2..-2, 1);
+
+# Start equal stop: positive increment
+seq(2..2, 1);
+
+# Start equal stop: negative increment
+seq(2..2, -1);
+
+# Start equal stop: zero increment
+seq(2..2, 0);
+
+# Start equal stop equal zero: zero increment
+seq(0..0, 0);

Task/Loops-Wrong-ranges/Mathematica/loops-wrong-ranges.math

@@ -0,0 +1,9 @@
+Table[i, {i, -2, 2, 1}]
+Table[i, {i, -2, 2, 0}]
+Table[i, {i, -2, 2, -1}]
+Table[i, {i, -2, 2, 10}]
+Table[i, {i, 2, -2, 1}]
+Table[i, {i, 2, 2, 1}]
+Table[i, {i, 2, 2, -1}]
+Table[i, {i, 2, 2, 0}]
+Table[i, {i, 0, 0, 0}]

Task/Loops-Wrong-ranges/Minimal-BASIC/loops-wrong-ranges.basic

@@ -0,0 +1,25 @@
+100 CLS : REM  100 HOME for Applesoft BASIC : REM DELETE line for Minimal BASIC
+110 DATA -2,2,1,"Normal",-2,2,0,"Zero increment"
+120 DATA -2,2,-1,"Increments away from stop value"
+130 DATA -2,2,10,"First increment is beyond stop value"
+140 DATA 2,-2,1,"Start more than stop: positive increment"
+150 DATA 2,2,1,"Start equal stop: positive increment"
+160 DATA 2,2,-1,"Start equal stop: negative increment"
+170 DATA 2,2,0,"Start equal stop: zero increment"
+180 DATA 0,0,0,"Start equal stop equal zero: zero increment"
+190 FOR j = 1 TO 9
+200  LET c = 0
+210  READ s, f, i, t$
+220  PRINT t$
+230  PRINT "  Bucle de "; s; "a "; f; " en incrementos de "; i
+240  FOR v = s TO f STEP i
+250   PRINT "        Indice del bucle = "; v
+260   LET c = c + 1
+270   IF c <> 10 THEN 300
+280   PRINT "        Saliendo de un bucle infinito"
+290   GOTO 310
+300  NEXT v
+310  PRINT "  Bucle terminado"
+320  PRINT
+330 NEXT j
+340 END

Task/Loops-Wrong-ranges/Nim/loops-wrong-ranges.nim

@@ -0,0 +1,14 @@
+import sequtils, strformat
+
+proc displayRange(first, last, step: int) =
+
+  stdout.write &"({first:>2}, {last:>2}, {step:>2}):   "
+
+  echo if step > 0: ($toSeq(countup(first, last, step)))[1..^1]
+       elif step < 0: ($toSeq(countdown(first, last, -step)))[1..^1]
+       else: "not allowed."
+
+for (f, l, s) in [(-2, 2, 1), (-2, 2, 0), (-2, 2, -1),
+                  (-2, 2, 10), (2, -2, 1), (2, 2, 1),
+                  (2, 2, -1), (2, 2, 0), (0, 0, 0)]:
+  displayRange(f, l, s)

Task/Loops-Wrong-ranges/PL-I/loops-wrong-ranges.pli

@@ -0,0 +1,33 @@
+loops:procedure options (main);
+   declare i fixed binary;
+
+   put skip list ('-2 to 2 by  1:');
+   do i = -2 to 2 by 1;
+      put edit (i) (f(3));
+   end;
+   put skip list ('-2 to 2 by  0: infinite loop, prints -2');
+
+   put skip list ('-2 to 2 by -1: [no values printed]');
+   do i = -2 to 2 by -1;
+      put edit (i) (f(3));
+   end;
+
+   put skip list ('-2 to 2 by 10:');
+   do i = -2 to 2 by 1;
+      put edit (i) (f(3));
+   end;
+
+   put skip list (' 2 to 2 by  1:');
+   do i = 2 to 2 by 1;
+      put edit (i) (f(3));
+   end;
+
+   put skip list (' 2 to 2 by -1:');
+   do i = 2 to 2 by -1;
+      put edit (i) (f(3));
+   end;
+
+   put skip list (' 2 to 2 by  0: infinite loop, prints 2');
+   put skip list (' 0 to 0 by  0: infinite loop, prints 0');
+
+end loops;

Task/Loops-Wrong-ranges/Perl/loops-wrong-ranges.pl

@@ -0,0 +1,25 @@
+for $i (
+     [ -2,    2,    1], #1 Normal
+     [ -2,    2,    0], #2 Zero increment
+     [ -2,    2,   -1], #3 Increments away from stop value
+     [ -2,    2,   10], #4 First increment is beyond stop value
+     [  2,   -2,    1], #5 Start more than stop: positive increment
+     [  2,    2,    1], #6 Start equal stop: positive increment
+     [  2,    2,   -1], #7 Start equal stop: negative increment
+     [  2,    2,    0], #8 Start equal stop: zero increment
+     [  0,    0,    0], #9 Start equal stop equal zero: zero increment
+) {
+    $iter = gen_seq(@$i);
+    printf "start: %3d  stop: %3d  incr: %3d | ", @$i;
+    printf "%4s", &$iter for 1..10;
+    print "\n";
+}
+
+sub gen_seq {
+    my($start,$stop,$increment) = @_;
+    $n = 0;
+    return sub {
+        $term = $start + $n++ * $increment;
+        return $term > $stop ? '' : $term;
+    }
+}

Task/Loops-Wrong-ranges/Phix/loops-wrong-ranges.phix

@@ -0,0 +1,42 @@
+-->
+ <span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">start</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">stop</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">step</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">legend</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">bool</span> <span style="color: #000000;">bFor</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
+     <span style="color: #008080;">if</span> <span style="color: #000000;">bFor</span> <span style="color: #008080;">then</span>
+         <span style="color: #008080;">try</span>
+             <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">start</span> <span style="color: #008080;">to</span> <span style="color: #000000;">stop</span> <span style="color: #008080;">by</span> <span style="color: #000000;">step</span> <span style="color: #008080;">do</span>
+                 <span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">i</span>
+                 <span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)></span><span style="color: #000000;">9</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+             <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+             <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span>
+         <span style="color: #008080;">catch</span> <span style="color: #000000;">e</span>
+             <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">e</span><span style="color: #0000FF;">[</span><span style="color: #000000;">E_USER</span><span style="color: #0000FF;">]</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">try</span>
+     <span style="color: #008080;">else</span>
+         <span style="color: #004080;">integer</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">start</span>
+         <span style="color: #008080;">while</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">step</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #000000;">i</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">stop</span><span style="color: #0000FF;">)</span>
+            <span style="color: #008080;">or</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">step</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">0</span> <span style="color: #008080;">and</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">stop</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+             <span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">i</span>
+             <span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)></span><span style="color: #000000;">9</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+ <span style="color: #000080;font-style:italic;">--          if i=stop then exit end if
+ --          if step=0 then exit end if</span>
+             <span style="color: #000000;">i</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">step</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+         <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%-43s: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">legend</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
+
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">2</span> <span style="color: #008080;">do</span>
+     <span style="color: #0000FF;">?</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">?</span><span style="color: #008000;">"for"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"while"</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Normal"</span>                                     <span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Zero increment"</span>                             <span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Increments away from stop value"</span>            <span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"First increment is beyond stop value"</span>       <span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Start more than stop: positive increment"</span>   <span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Start equal stop: positive increment"</span>       <span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Start equal stop: negative increment"</span>       <span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Start equal stop: zero increment"</span>           <span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Start equal stop equal zero: zero increment"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+<!--

Task/Loops-Wrong-ranges/Python/loops-wrong-ranges.py

@@ -0,0 +1,34 @@
+import re
+from itertools import islice # To limit execution if it would generate huge values
+# list(islice('ABCDEFG', 2)) --> ['A', 'B']
+# list(islice('ABCDEFG', 4)) --> ['A', 'B', 'C', 'D']
+
+
+data = '''
+start 	stop 	increment 	Comment
+-2 	2 	1 	Normal
+-2 	2 	0 	Zero increment
+-2 	2 	-1 	Increments away from stop value
+-2 	2 	10 	First increment is beyond stop value
+2 	-2 	1 	Start more than stop: positive increment
+2 	2 	1 	Start equal stop: positive increment
+2 	2 	-1 	Start equal stop: negative increment
+2 	2 	0 	Start equal stop: zero increment
+0 	0 	0 	Start equal stop equal zero: zero increment
+'''
+
+table = [re.split(r'\s\s+', line.strip()) for line in data.strip().split('\n')]
+#%%
+for _start, _stop, _increment, comment in table[1:]:
+    start, stop, increment = [int(x) for x in (_start, _stop, _increment)]
+    print(f'{comment.upper()}:\n  range({start}, {stop}, {increment})')
+    values = None
+    try:
+        values = list(islice(range(start, stop, increment), 999))
+    except ValueError as e:
+        print('  !!ERROR!!', e)
+    if values is not None:
+        if len(values) < 22:
+            print('    =', values)
+        else:
+            print('    =', str(values[:22])[:-1], '...')

Task/Loops-Wrong-ranges/R/loops-wrong-ranges.r

@@ -0,0 +1,9 @@
+seq(from = -2, to = 2, by = 1)#Output: -2 -1  0  1  2
+seq(from = -2, to = 2, by = 0)#Fails: "invalid '(to - from)/by'"
+seq(from = -2, to = 2, by = -1)#Fails: As in the notes above - "Specifying to - from and by of opposite signs is an error."
+seq(from = -2, to = 2, by = 10)#Output: -2
+seq(from = 2, to = -2, by = 1)#Fails: Same as the third case.
+seq(from = 2, to = 2, by = 1)#Output: 2
+seq(from = 2, to = 2, by = -1)#Output: 2
+seq(from = 2, to = 2, by = 0)#Output: 2
+seq(from = 0, to = 0, by = 0)#Output: 0

Task/Loops-Wrong-ranges/REXX/loops-wrong-ranges.rexx

@@ -0,0 +1,26 @@
+/*REXX program demonstrates several versions of  DO  loops with  "unusual"  iterations. */
+@.=;      @.1=  '  -2      2       1  '      /*"normal".                                */
+          @.2=  '  -2      2       0  '      /*"normal",                zero  increment.*/
+          @.3=  '  -2      2      -1  '      /*increases away from stop, neg  increment.*/
+          @.4=  '  -2      2      10  '      /*1st increment > stop, positive increment.*/
+          @.5=  '   2     -2       1  '      /*start > stop,         positive increment.*/
+          @.6=  '   2      2       1  '      /*start equals stop,    positive increment.*/
+          @.7=  '   2      2      -1  '      /*start equals stop,    negative increment.*/
+          @.8=  '   2      2       0  '      /*start equals stop,       zero  increment.*/
+          @.9=  '   0      0       0  '      /*start equals stop,       zero  increment.*/
+zLim= 10                                     /*a limit to check for runaway (race) loop.*/
+                                             /*a zero increment is not an error in REXX.*/
+  do k=1  while  @.k\==''                    /*perform a  DO  loop with several ranges. */
+  parse var   @.k    x  y  z  .              /*obtain the three values for a DO loop.   */
+  say
+  say center('start of performing DO loop number '   k   " with range: "  x y z,  79, '═')
+  zz= 0
+        do  j=x   to y   by z   until zz>=zLim           /* ◄───  perform the  DO  loop.*/
+        say '   j ───►'  right(j, max(3, length(j) ) )   /*right justify J for alignment*/
+        if z==0  then zz= zz + 1                         /*if zero inc, count happenings*/
+        end   /*j*/
+
+  if zz>=zLim  then say 'the DO loop for the '    k    " entry was terminated (runaway)."
+  say center(' end  of performing DO loop number '   k   " with range: "  x y z,  79, '─')
+  say
+  end         /*k*/                              /*stick a fork in it,  we're all done. */

Task/Loops-Wrong-ranges/Racket/loops-wrong-ranges.rkt

@@ -0,0 +1,21 @@
+#lang racket
+
+(require racket/sandbox)
+
+(define tests '([-2  2  1 "Normal"]
+                [-2  2  0 "Zero increment"]
+                [-2  2 -1 "Increments away from stop value"]
+                [-2  2 10 "First increment is beyond stop value"]
+                [2  -2  1 "Start more than stop: positive increment"]
+                [2   2  1 "Start equal stop: positive increment"]
+                [2   2 -1 "Start equal stop: negative increment"]
+                [2   2  0 "Start equal stop: zero increment"]
+                [0   0  0 "Start equal stop equal zero: zero increment"]))
+
+(for ([test (in-list tests)])
+  (match-define (list st ed inc desc) test)
+  (printf "~a:\n  (in-range ~a ~a ~a) = ~a\n\n"
+          desc st ed inc
+          (with-handlers ([exn:fail:resource? (thunk* 'timeout)])
+            (with-limits 1 #f
+              (sequence->list (in-range st ed inc))))))

Task/Loops-Wrong-ranges/Raku/loops-wrong-ranges.raku

@@ -0,0 +1,37 @@
+# Given sequence definitions
+#   start  stop  inc.   Comment
+for   -2,    2,    1, # Normal
+      -2,    2,    0, # Zero increment
+      -2,    2,   -1, # Increments away from stop value
+      -2,    2,   10, # First increment is beyond stop value
+       2,   -2,    1, # Start more than stop: positive increment
+       2,    2,    1, # Start equal stop: positive increment
+       2,    2,   -1, # Start equal stop: negative increment
+       2,    2,    0, # Start equal stop: zero increment
+       0,    0,    0, # Start equal stop equal zero: zero increment
+
+# Additional "problematic" sequences
+       1,  Inf,    3, # Endpoint literally at infinity
+       0,    π,  τ/8, # Floating point numbers
+     1.4,    *, -7.1  # Whatever
+
+  -> $start, $stop, $inc {
+    my $seq = flat ($start, *+$inc … $stop);
+    printf "Start: %3s, Stop: %3s, Increment: %3s | ", $start, $stop.Str, $inc;
+    # only show up to the first 15 elements of possibly infinite sequences
+    put $seq[^15].grep: +*.defined
+}
+
+# For that matter the start and end values don't need to be numeric either. Both
+# or either can be a function, list, or other object. Really anything that a
+# "successor" function can be defined for and produces a value.
+say "\nDemonstration of some other specialized sequence operator functionality:";
+# Start with a list, iterate by multiplying the previous 3 terms together
+# and end with a term defined by a function.
+put 1, -.5, 2.sqrt, * × * × * … *.abs < 1e-2;
+
+# Start with an array, iterate by rotating, end when 0 is in the last place.
+say [0,1,2,3,4,5], *.rotate(-1).Array … !*.tail;
+
+# Iterate strings backwards.
+put 'xp' … 'xf';

Task/Loops-Wrong-ranges/Ruby/loops-wrong-ranges.rb

@@ -0,0 +1,16 @@
+examples = [
+     [ -2,    2,    1],
+     [ -2,    2,    0],
+     [ -2,    2,   -1],
+     [ -2,    2,   10],
+     [  2,   -2,    1],
+     [  2,    2,    1],
+     [  2,    2,   -1],
+     [  2,    2,    0],
+     [  0,    0,    0]
+     ]
+
+examples.each do |start, stop, step|
+  as = (start..stop).step(step)
+  puts "#{as.inspect} size: #{as.size}"
+end

Task/Loops-Wrong-ranges/Seed7/loops-wrong-ranges.seed7

@@ -0,0 +1,37 @@
+$ include "seed7_05.s7i";
+
+const proc: testLoop (in integer: start, in integer: stop, in integer: incr, in string: comment) is func
+  local
+    const integer: limit is 10;
+    var integer: number is 0;
+    var integer: count is 0;
+  begin
+    writeln(comment);
+    write("Range(" <& start <& ", " <& stop <& ", " <& incr <& ") -> [ ");
+    block
+      for number range start to stop step incr do
+        write(number <& " ");
+        incr(count);
+        if count >= limit then
+          raise RANGE_ERROR;
+        end if;
+      end for;
+    exception
+      catch RANGE_ERROR: noop;
+    end block;
+    writeln("]");
+    writeln;
+  end func;
+
+const proc: main is func
+  begin
+    testLoop(-2,  2,  1, "Normal");
+    testLoop(-2,  2,  0, "Zero increment");
+    testLoop(-2,  2, -1, "Increments away from stop value");
+    testLoop(-2,  2, 10, "First increment is beyond stop value");
+    testLoop( 2, -2,  1, "Start more than stop: positive increment");
+    testLoop( 2,  2,  1, "Start equal stop: positive increment");
+    testLoop( 2,  2, -1, "Start equal stop: negative increment");
+    testLoop( 2,  2,  0, "Start equal stop: zero increment");
+    testLoop( 0,  0,  0, "Start equal stop equal zero: zero increment");
+  end func;

Task/Loops-Wrong-ranges/Smalltalk/loops-wrong-ranges-1.st

@@ -0,0 +1 @@
+startExpr to:stopExpr by:incExpr do:[..]

Task/Loops-Wrong-ranges/Smalltalk/loops-wrong-ranges-2.st

@@ -0,0 +1,32 @@
+MAX_ITER := 15.
+#(
+  (-2  2  1 'Normal')
+  (-2  2  0 'Zero increment')
+  (-2  2 -1 'Increments away from stop value')
+  (-2  2 10 'First increment is beyond stop value')
+  (2  -2  1 'Start more than stop: positive increment')
+  (2   2  1 'Start equal stop: positive increment')
+  (2   2 -1 'Start equal stop: negative increment')
+  (2   2  0 'Start equal stop: zero increment')
+  (0   0  0 'Start equal stop equal zero: zero increment')
+) do:[:testParams |
+    |start stop inc info countIter|
+
+    start := testParams first.
+    stop := testParams second.
+    inc := testParams third.
+    info := testParams fourth.
+    Transcript show:(info paddedTo:50 with:$.).
+
+    countIter := 0.
+    [:exit |
+        start to:stop by:inc do:[:n |
+            Transcript space; show:n.
+            (countIter := countIter + 1) > MAX_ITER ifTrue:[
+                Transcript show:'...'.
+                exit value
+            ].
+        ].
+    ] valueWithExit.
+    Transcript cr.
+].

Task/Loops-Wrong-ranges/V-(Vlang)/loops-wrong-ranges.v

@@ -0,0 +1,36 @@
+struct Seq {
+    start int
+    stop int
+    incr int
+    comment string
+}
+
+const examples = [
+    Seq{-2, 2, 1, "Normal"},
+    Seq{-2, 2, 0, "Zero increment"},
+    Seq{-2, 2, -1, "Increments away from stop value"},
+    Seq{-2, 2, 10, "First increment is beyond stop value"},
+    Seq{2, -2, 1, "Start more than stop: positive increment"},
+    Seq{2, 2, 1, "Start equal stop: positive increment"},
+    Seq{2, 2, -1, "Start equal stop: negative increment"},
+    Seq{2, 2, 0, "Start equal stop: zero increment"},
+    Seq{0, 0, 0, "Start equal stop equal zero: zero increment"},
+]
+
+fn sequence(s Seq, limit int) []int {
+    mut seq := []int{}
+    for i, c := s.start, 0; i <= s.stop && c < limit; i, c = i+s.incr, c+1 {
+        seq << i
+    }
+    return seq
+}
+
+fn main() {
+    limit := 10
+    for ex in examples {
+        println(ex.comment)
+        print("Range($ex.start, $ex.stop, $ex.incr) -> ")
+        println(sequence(ex, limit))
+        println('')
+    }
+}

Task/Loops-Wrong-ranges/VBA/loops-wrong-ranges.vba

@@ -0,0 +1,25 @@
+Public Sub LoopsWrongRanges()
+    Call Example(-2, 2, 1, "Normal")
+    Call Example(-2, 2, 0, "Zero increment")
+    Call Example(-2, 2, -1, "Increments away from stop value")
+    Call Example(-2, 2, 10, "First increment is beyond stop value")
+    Call Example(2, -2, 1, "Start more than stop: positive increment")
+    Call Example(2, 2, 1, "Start equal stop: positive increment")
+    Call Example(2, 2, -1, "Start equal stop: negative increment")
+    Call Example(2, 2, 0, "Start equal stop: zero increment")
+    Call Example(0, 0, 0, "Start equal stop equal zero: zero increment")
+End Sub
+Private Sub Example(start As Integer, stop_ As Integer, by As Integer, comment As String)
+    Dim i As Integer
+    Dim c As Integer
+    Const limit = 10
+    c = 0
+    Debug.Print start; " "; stop_; " "; by; " | ";
+    For i = start To stop_ Step by
+        Debug.Print i & ",";
+        c = c + 1
+        If c > limit Then Exit For
+    Next i
+    Debug.Print
+    Debug.Print comment & vbCrLf
+End Sub

Task/Loops-Wrong-ranges/Vala/loops-wrong-ranges.vala

@@ -0,0 +1,22 @@
+static void example(int start, int stop, int increment, string comment) {
+  const int MAX_ITER = 9;
+  int iteration = 0;
+  stdout.printf("%-50s", comment);
+  for (int i = start; i <= stop; i += increment) {
+    stdout.printf("%3d ", i);
+    if (++iteration > MAX_ITER) break;
+  }
+  stdout.printf("\n");
+}
+
+void main () {
+  example(-2, 2, 1, "Normal");
+  example(-2, 2, 0, "Zero increment");
+  example(-2, 2, -1, "Increments away from stop value");
+  example(-2, 2, 10, "First increment is beyond stop value");
+  example(2, -2, 1, "Start more than stop: positive increment");
+  example(2, 2, 1, "Start equals stop: positive increment");
+  example(2, 2, -1, "Start equals stop: negative increment");
+  example(2, 2, 0, "Start equals stop: zero increment");
+  example(0, 0, 0, "Start equals stop equal zero: zero increment");
+}

Task/Loops-Wrong-ranges/Visual-Basic-.NET/loops-wrong-ranges.vb

@@ -0,0 +1,38 @@
+Module Program
+    Sub Main()
+        Example(-2, 2, 1, "Normal")
+        Example(-2, 2, 0, "Zero increment")
+        Example(-2, 2, -1, "Increments away from stop value")
+        Example(-2, 2, 10, "First increment is beyond stop value")
+        Example(2, -2, 1, "Start more than stop: positive increment")
+        Example(2, 2, 1, "Start equal stop: positive increment")
+        Example(2, 2, -1, "Start equal stop: negative increment")
+        Example(2, 2, 0, "Start equal stop: zero increment")
+        Example(0, 0, 0, "Start equal stop equal zero: zero increment")
+    End Sub
+
+    ' Stop is a keyword and must be escaped using brackets.
+    Iterator Function Range(start As Integer, [stop] As Integer, increment As Integer) As IEnumerable(Of Integer)
+        For i = start To [stop] Step increment
+            Yield i
+        Next
+    End Function
+
+    Sub Example(start As Integer, [stop] As Integer, increment As Integer, comment As String)
+        ' Add a space, pad to length 50 with hyphens, and add another space.
+        Console.Write((comment & " ").PadRight(50, "-"c) & " ")
+
+        Const MAX_ITER = 9
+
+        Dim iteration = 0
+        ' The For Each loop enumerates the IEnumerable.
+        For Each i In Range(start, [stop], increment)
+            Console.Write("{0,2} ", i)
+
+            iteration += 1
+            If iteration > MAX_ITER Then Exit For
+        Next
+
+        Console.WriteLine()
+    End Sub
+End Module

Task/Loops-Wrong-ranges/Wren/loops-wrong-ranges.wren

@@ -0,0 +1,20 @@
+import "/fmt" for Fmt
+
+var loop = Fn.new { |start, stop, inc|
+    System.write("%(Fmt.v("dm", 3, [start, stop, inc], 0, " ", "[]")) -> ")
+    var count = 0
+    var limit = 10
+    var i = start
+    while (i <= stop) {
+        System.write("%(i) ")
+        count = count + 1
+        if (count == limit) break
+        i = i + inc
+    }
+    System.print()
+}
+
+var tests = [
+    [-2, 2, 1], [-2, 2, 0], [-2, 2, -1], [-2, 2, 10], [2, -2, 1], [2, 2, 1], [2, 2, -1], [2, 2, 0], [0, 0, 0]
+]
+for (test in tests) loop.call(test[0], test[1], test[2])

Task/Loops-Wrong-ranges/XPL0/loops-wrong-ranges.xpl0

@@ -0,0 +1,32 @@
+include xpllib; \for Print
+
+def \S\ Start, Stop, Incr, Comment;
+int S, Examples, I, J, C, Empty;
+def Limit = 10;
+[Examples:= [
+    [-2, 2, 1, "Normal"],
+    [-2, 2, 0, "Zero increment"],
+    [-2, 2, -1, "Increments away from stop value"],
+    [-2, 2, 10, "First increment is beyond stop value"],
+    [2, -2, 1, "Start more than stop: positive increment"],
+    [2, 2, 1, "Start equal stop: positive increment"],
+    [2, 2, -1, "Start equal stop: negative increment"],
+    [2, 2, 0, "Start equal stop: zero increment"],
+    [0, 0, 0, "Start equal stop equal zero: zero increment"]
+  ];
+for I:= 0 to 9-1 do
+    [S:= Examples(I);
+    Print("%s\n", S(Comment));
+    Print("Range(%d, %d, %d) -> [", S(Start), S(Stop), S(Incr));
+    Empty:= true;
+\\  for (j:= s.start, c:= 0; j <= s.stop && c < limit; j += s.incr, ++c)
+    J:= S(Start);  C:= 0;
+    while J <= S(Stop) and C < Limit do
+        [Print("%d ", J);
+        Empty:= false;
+        J:= J + S(Incr);  C:= C+1;
+        ];
+    if not Empty then ChOut(0, $08 \BS\);
+    Print("]\n\n");
+    ]
+]

Task/Loops-Wrong-ranges/Yabasic/loops-wrong-ranges.basic

@@ -0,0 +1,21 @@
+data -2,2,1,"Normal",-2,2,0,"Zero increment",-2,2,-1,"Increments away from stop value"
+data -2,2,10,"First increment is beyond stop value",2,-2,1,"Start more than stop: positive increment"
+data 2,2,1,"Start equal stop: positive increment",2,2,-1,"Start equal stop: negative increment"
+data 2,2,0,"Start equal stop: zero increment",0,0,0,"Start equal stop equal zero: zero increment"
+
+for i = 1 to 9
+    contar = 0
+    read start, fin, inc, cmt$
+    print cmt$
+    print "  Bucle de ", start, " a ", fin, " en incrementos de ", inc
+    for vr = start to fin step inc
+        print "        Indice del bucle = ", vr
+        contar = contar + 1
+        if contar = 10 then
+            print "        Saliendo de un bucle infinito"
+            break
+        endif
+    next vr
+    print "  Bucle terminado\n\n"
+next i
+end

Task/Loops-Wrong-ranges/Zkl/loops-wrong-ranges.zkl

@@ -0,0 +1,16 @@
+// zero increment (ie infnite loop) throws an error
+// if stop is "*", the loop is has no end (ie infinite)
+// stop is included unless step steps skips it
+// if start > stop is a dead loop
+// ranges ([a..b,c]) are lazy lists
+fcn looper([(start,stop,increment)]){
+   print(" %3s  %3s\t%2d --> ".fmt(start,stop,increment));
+   try{ foreach n in ([start..stop,increment]){ print(n," ") } }
+   catch{ print(__exception) }
+   println();
+}
+println("start stop  increment");
+T( T(-2,2,1),T(-2,2,0),T(-2,2,-1),T(-2,2,10),T( 2,-2,1),
+   T( 2,2,1),T( 2,2,-1),T( 2,2,0),T( 0,0,0),
+   T(0.0, (0.0).pi, 0.7853981633974483), T("a","e",1), T("e","a",1) )
+.apply2(looper);  // apply2 is apply (map) without saving results