Integer sequence

Task

Create a program that, when run, would display all integers from 1 to ∞ (or any relevant implementation limit), in sequence (i.e. 1, 2, 3, 4, etc) if given enough time.

An example may not be able to reach arbitrarily-large numbers based on implementations limits. For example, if integers are represented as a 32-bit unsigned value with 0 as the smallest representable value, the largest representable value would be 4,294,967,295. Some languages support arbitrarily-large numbers as a built-in feature, while others make use of a module or library.

If appropriate, provide an example which reflect the language implementation's common built-in limits as well as an example which supports arbitrarily large numbers, and describe the nature of such limitations—or lack thereof.

0815

11l

<lang 11l>L(i) 1..

  print(i)</lang>

360 Assembly

For maximum compatibility, this program uses only the basic instruction set (S/360). <lang 360asm>* Integer sequence 06/05/2016 INTSEQED CSECT

        USING  INTSEQED,12
        LR    12,15
        LA    6,1             i=1

LOOP CVD 6,DW binary to pack decimal

        MVC   WTOMSG+4(12),EM12 load mask
        ED    WTOMSG+4(12),DW+2 packed dec to char
        WTO   MF=(E,WTOMSG)   write to console
        LA    6,1(6)          i=i+1
        B     LOOP            goto loop

WTOMSG DC 0F,H'80',H'0',CL80' ' DW DS 0D,PL8 pack dec 15num EM12 DC X'402020202020202020202120' mask CL12 11num

        END   INTSEQED</lang>

Output:

8080 Assembly

Actually printing the numbers out would depend on the hardware and operating system. <lang 8080asm> ORG 0100H

       MVI     A,    0   ; move immediate

LOOP: INR A ; increment

  ; call 'PRINT' subroutine, if required
       JMP     LOOP      ; jump unconditionally

       END</lang>

A more complex, arbitrary precision version that can count as high as you have free bytes of memory to use. (This does assemble with CP/M's MAC assembler, but since it doesn't implement PRBUFR, it's only useful for exposition purposes, or for loading into DDT.)

       ORG     0100H

BITS EQU 128 ; 128 bits of precision BYTES EQU BITS / 8 ; Number of bytes we store those bits in

       ; Zero out the storage for our number
       LXI     H,BUFR    ; HL points at BUFR. (HL is idiomatically used for pointers)
       MVI     C,BYTES   ; C holds the number of bytes we'll use
       XRA     A         ; XOR with A is a 1-byte instruction to set A to zero

INIT: MOV M,A ; Store 0 to address pointed to by HL

       INX     H         ; Advance HL to the next byte
       DCR     C         ; Count down
       JNZ     INIT      ; Keep looping if we're not done

       ; The "very long integer" is zeroed, so start the loop

LOOP: CALL PRBUFR ; Output our number

       LXI     H,BUFR    ; HL Points to BUFR
       MVI     C,BYTES   ; Count down (assume fewer than 256 bytes in our integer)

NEXT: INR M ; Increment the byte pointed to by HL. Sets the zero flag

       JNZ     LOOP      ; If the increment didn't overflow A, start the loop over
                         ; This byte overflowed, so we need to advance to the next byte in our number
       INX     H         ; We store our byes in order of increasing significance
       DCR     C         ; Count down to make sure we don't overflow our buffer
       JNZ     NEXT      ; jump to process the next, more significant byte

       ; If we get here, we have overflowed our integer!
       HALT              ; TODO: probably something other than "halt the CPU"

PRBUFR: ; TODO, a subroutine that shows all of the digits in BUFR on the console

       ; Assume that this code trashes all our registers...
       RET

BUFR: ; This space will hold our number

       ; We zero this memory before the loop
       END</lang>

Action!

<lang Action!>PROC Main()

 CARD i

 i=0
 DO 
   PrintF("%U ",i)
   i==+1
 UNTIL i=0
 OD

RETURN</lang>

Output:

Screenshot from Atari 8-bit computer

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 ...

Ada

<lang Ada>with Ada.Text_IO; procedure Integers is

  Value : Integer := 1;

begin

  loop
     Ada.Text_IO.Put_Line (Integer'Image (Value));
     Value := Value + 1;  -- raises exception Constraint_Error on overflow
  end loop;

end Integers;</lang> Alternative (iterating through all values of Positive (positive part of Integer) without endless loop): <lang Ada>with Ada.Text_IO; procedure Positives is begin

  for Value in Positive'Range loop
     Ada.Text_IO.Put_Line (Positive'Image (Value));
  end loop;

end Positives;</lang>

ALGOL 68

Works with: ALGOL 68 version Revision 1 - no extensions to language used.

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny.

The upper limit of the loop variable i is max int currently +2147483647 for ALGOL 68G. <lang algol68>main: (

 FOR i DO
   printf(($g(0)","$,i))
 OD

)</lang> Partial output:

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,...

ALGOL W

<lang algolw>begin

   % print the integers from 1 onwards                                       %
   % Algol W only has 32-bit integers. When i reaches 2^32,                  %
   % an integer overflow event would be raised which by default,             %
   % should terminate the program                                            %
   integer i;
   i := 1;
   while true do begin
       write( i );
       i := i + 1
   end loop_forever ;

end.</lang>

Applesoft BASIC

Integer variables can be within the range of -32767 to 32767. <lang Applesoft BASIC> 10 I% = 1

20  PRINT I%;
30 I% = I% + 1
40  PRINT ", ";
50  GOTO 20</lang>

Last screen of scrolled output: <lang Applesoft BASIC>, 32646, 32647, 32648, 32649, 32650, 326 51, 32652, 32653, 32654, 32655, 32656, 3 2657, 32658, 32659, 32660, 32661, 32662,

32663, 32664, 32665, 32666, 32667, 3266

8, 32669, 32670, 32671, 32672, 32673, 32 674, 32675, 32676, 32677, 32678, 32679, 32680, 32681, 32682, 32683, 32684, 32685 , 32686, 32687, 32688, 32689, 32690, 326 91, 32692, 32693, 32694, 32695, 32696, 3 2697, 32698, 32699, 32700, 32701, 32702,

32703, 32704, 32705, 32706, 32707, 3270

8, 32709, 32710, 32711, 32712, 32713, 32 714, 32715, 32716, 32717, 32718, 32719, 32720, 32721, 32722, 32723, 32724, 32725 , 32726, 32727, 32728, 32729, 32730, 327 31, 32732, 32733, 32734, 32735, 32736, 3 2737, 32738, 32739, 32740, 32741, 32742,

32743, 32744, 32745, 32746, 32747, 3274

8, 32749, 32750, 32751, 32752, 32753, 32 754, 32755, 32756, 32757, 32758, 32759, 32760, 32761, 32762, 32763, 32764, 32765 , 32766, 32767 ?ILLEGAL QUANTITY ERROR IN 30 ]</lang>

ARM Assembly

<lang armasm>.text .global main

@ An ARM program that keeps incrementing R0 forever @ @ If desired, a call to some 'PRINT' routine -- @ which would depend on the OS -- could be included

main:

       mov   r0,   #0          @ start with R0 = 0

repeat:

       @ call to 'PRINT' routine
       add   r0,   r0,   #1    @ increment R0
       b     repeat            @ unconditional branch</lang>

ArnoldC

<lang arnoldc>IT'S SHOWTIME HEY CHRISTMAS TREE n YOU SET US UP @NO PROBLEMO STICK AROUND @NO PROBLEMO TALK TO THE HAND n GET TO THE CHOPPER n HERE IS MY INVITATION n GET UP @NO PROBLEMO ENOUGH TALK CHILL YOU HAVE BEEN TERMINATED</lang>

Arturo

<lang rebol>i:0 while ø [

   print i
   inc 'i

]</lang>

AutoHotkey

This uses traytip to show the results. A msgbox, tooltip, or fileappend could also be used. <lang AutoHotkey>x=0 Loop

   TrayTip, Count, % ++x</lang>

AWK

<lang awk>BEGIN {

   for( i=0; i != i + 1; i++ )
       print( i )

}</lang>

Awk uses floating-point numbers. This loop terminates when i becomes too large for integer precision. With IEEE doubles, this loop terminates when i reaches 2 ^ 53.

Axe

Integers in Axe are limited to 16 bits, or a maximum of 65535. This script will run infinitely until either the variable overflows or a key is pressed.

<lang axe>While getKey(0) End 0→I Repeat getKey(0)

Disp I▶Dec,i
I++

EndIf I=0</lang>

BASIC

Works with: ZX Spectrum Basic

<lang zxbasic>10 LET A = 0 20 LET A = A + 1 30 PRINT A 40 GO TO 20</lang>

Works with: QBasic

<lang qbasic>A = 0 DO: A = A + 1: PRINT A: LOOP 1</lang>

BASIC256

<lang BASIC256>i = 1

do

   print i
   i += 1

until i = 0</lang>

Batch File

Variables are limited to 32bit integer, capable of a maximum value of 2,147,483,647 <lang dos> @echo off set number=0

loop

set /a number+=1 echo %number% goto loop </lang>

Output:

...
2147483644
2147483645
2147483646
2147483647
-2147483648
-2147483647
-2147483646
-2147483645
...

BBC BASIC

Works with: BBC BASIC for Windows

Native version, limited to 53-bit integers (maximum output 9007199254740992): <lang bbcbasic> *FLOAT 64

     REPEAT
       i += 1
       PRINT TAB(0,0) i;
     UNTIL FALSE</lang>

Version using Huge Integer Math and Encryption library (up to 2^31 bits, but this program limited to 65535 decimal digits because of maximum string length): <lang bbcbasic> INSTALL @lib$+"HIMELIB"

     PROC_himeinit("")
     reg% = 1
     
     PROC_hiputdec(reg%, "0")
     REPEAT
       SYS `hi_Incr`, ^reg%, ^reg%
       PRINT TAB(0,0) FN_higetdec(reg%);
     UNTIL FALSE</lang>

bc

<lang bc>while (++i) i</lang>

beeswax

Using an ordinary loop structure: <lang beeswax> qNP< _1>{d</lang>

Using a jump instruction: <lang beeswax>_1F6~@{PN@J</lang>

Numbers in beeswax are unsigned 64-bit integers, so after reaching 2^64-1 the counter wraps around to 0.

Befunge

The range of a numeric value in Befunge is implementation dependent, but is commonly 32 bit signed integers for the stack, so a maximum value of 2147483647. However, note that some implementations have a smaller range for displayed values, so the sequence may appear to wrap to negative numbers while the internal value is in fact still increasing.

Also note that the range of values written to the code page or 'playfield' is often much smaller - frequently only supporting 8 bits, sometimes signed, sometimes unsigned.

BQN

While the input is lesser than or equal to infinity, print, then increment. <lang bqn>_while_ ← {𝔽⍟𝔾∘𝔽_𝕣_𝔾∘𝔽⍟𝔾𝕩} (1+•Show) _while_ (≤⟜∞) 1</lang>

Bracmat

Translation of: Ruby

Bracmat uses big numbers. Numbers are stored with a radix 10, each decimal digit occupying one byte. When multiplying or dividing, numbers are temporarily converted to radix 10000 (32-bit systems: 1 digit occupies two bytes) or radix 100000000 (64-bit systems: 1 digit occupies four bytes) to speed up the computation. <lang>0:?n&whl'out$(1+!n:?n)</lang>

Brainf***

This program assumes that decrementing past zero wraps around, but it doesn't rely on cell size, other than that a cell can hold at least six bits. It also assumes the ASCII character set. This is an arbitrarily large number implementation. <lang brainf***>++++++++++>>>+[[->>+<[+>->+<<---------------------------------------

[>>-<++++++++++<[+>-<]]>[-<+>]<++++++++++++++++++

++++++++++++++++++++++++++++++>]<[<]>>[-<+++++++++++++++++++++++++++ ++++++++++++++++++++++>]>]>[>>>]<<<[.<<<]<.>>>+]</lang>

This modification of the previous program will print out 1 to the maximum cell value, still assuming wrapping. On many implementations, this will print out 1-255. <lang brainf***>++++++++++>>-[>+[->>+<[+>->+<<--------------------------------------

[>>-<++++++++++<[+>-<]]>[-<+>]<+++++++++++++++++

+++++++++++++++++++++++++++++++>]<[<]>>[-<++++++++++++++++++++++++++ +++++++++++++++++++++++>]>]>[>>>]<<<[.<<<]<.>>-]</lang>

This program can count in any base counting system under 256. Note: Change the characters in quotes equal to the base counting system you want to use. <lang brainf***>+[<<+>>[[<<"-----------"["+++++++++++"<]>]>[<<<<+>>+>>[>>]<]<]>>[>>]<<]</lang>

Brat

<lang brat>i = 1

loop {

 p i
 i = i + 1

}</lang>

Burlesque

C

Prints from 1 to max unsigned integer (usually 2**32 -1), then stops. <lang c>#include <stdio.h>

int main() { unsigned int i = 0; while (++i) printf("%u\n", i);

return 0; }</lang>

Library: GMP

This one never stops. It's not even likely that you'll run out of memory before you run out of patience. <lang c>#include <gmp.h>

int main() { mpz_t i; mpz_init(i); /* zero now */

while (1) { mpz_add_ui(i, i, 1); /* i = i + 1 */ gmp_printf("%Zd\n", i); }

return 0; }</lang>

Library: OpenSSL

OpenSSL provides arbitrarily large integers.

<lang c>#include <openssl/bn.h> /* BN_*() */

include <openssl/err.h> /* ERR_*() */
include <stdio.h> /* fprintf(), puts() */

void fail(const char *message) { fprintf(stderr, "%s: error 0x%08lx\n", ERR_get_error()); exit(1); }

int main() { BIGNUM i; char *s;

BN_init(&i); for (;;) { if (BN_add_word(&i, 1) == 0) fail("BN_add_word"); s = BN_bn2dec(&i); if (s == NULL) fail("BN_bn2dec"); puts(s); OPENSSL_free(s); } /* NOTREACHED */ }</lang>

C#

<lang csharp>using System; using System.Numerics;

class Program {

   static void Main()
   {
       BigInteger i = 1;
       while (true)
       {
           Console.WriteLine(i++);
       }
   }

}</lang>

C++

<lang cpp>#include <cstdint>

include <iostream>
include <limits>

int main() {

 auto i = std::uintmax_t{};
 
 while (i < std::numeric_limits<decltype(i)>::max())
   std::cout << ++i << '\n';

}</lang>

ChucK

Math.INT_MAX is a constant value that represents the greater integer, 32 bit , 64 bit systems. <lang> for(1 => int i; i < Math.INT_MAX; i ++) {

   <<< i >>>;

} </lang>

Clean

In Clean this example has a limit of basically 2147483648. <lang Clean>module IntegerSequence

import StdEnv

Start = [x \\ x <- [1..]]</lang>

Output:

[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,..

Clojure

<lang Clojure>(map println (next (range)))</lang>

CLU

<lang clu>% This iterator will generate all integers until the built-in type % overflows. It is a signed machine-sized integer; so 64 bits on % a modern machine. After that it will raise an exception. to_infinity_and_beyond = iter () yields (int)

   i: int := 0
   while true do
       i := i + 1
       yield(i)
   end

end to_infinity_and_beyond

start_up = proc ()

   po: stream := stream$primary_output()
   
   for i: int in to_infinity_and_beyond() do
       stream$putl(po, int$unparse(i))
   end

end start_up </lang>

COBOL

<lang cobol> IDENTIFICATION DIVISION.

      PROGRAM-ID. Int-Sequence.

      DATA DIVISION.
      WORKING-STORAGE SECTION.

*> 36 digits is the largest size a numeric field can have.

      01  I PIC 9(36).

      PROCEDURE DIVISION.

*> Display numbers until I overflows.

          PERFORM VARYING I FROM 1 BY 1 UNTIL I = 0
              DISPLAY I
          END-PERFORM

          GOBACK
          .</lang>

CoffeeScript

Like with most languages, counting is straightforward in CoffeeScript, so the program below tries to handle very large numbers. See the comments for starting the sequence from 1.

This very limited BCD-based collection of functions
makes it easy to count very large numbers. All arrays
start off with the ones columns in position zero.
Using arrays of decimal-based digits to model integers
doesn't make much sense for most tasks, but if you
want to keep counting forever, this does the trick.

BcdInteger =

 from_string: (s) ->
   arr = []
   for c in s
     arr.unshift parseInt(c)
   arr

 render: (arr) ->
   s = 
   for elem in arr
     s = elem.toString() + s
   s
   
 succ: (arr) ->
   arr = (elem for elem in arr)
   i = 0
   while arr[i] == 9
     arr[i] = 0
     i += 1
   arr[i] ||= 0
   arr[i] += 1
   arr

To start counting from 1, change the next line!

big_int = BcdInteger.from_string "199999999999999999999999999999999999999999999999999999" while true

 console.log BcdInteger.render big_int
 big_int = BcdInteger.succ big_int

</lang>

output <lang> > coffee foo.coffee | head -5 199999999999999999999999999999999999999999999999999999 200000000000000000000000000000000000000000000000000000 200000000000000000000000000000000000000000000000000001 200000000000000000000000000000000000000000000000000002 200000000000000000000000000000000000000000000000000003 </lang>

Common Lisp

<lang lisp>(loop for i from 1 do (print i))</lang>

If your compiler does tail call elimination (note: this has absolutely no advantage over normal loops): <lang lisp>(defun pp (x) (pp (1+ (print x)))) (funcall (compile 'pp) 1) ; it's less likely interpreted mode will eliminate tails</lang>

Component Pascal

BlackBox Component Builder <lang oberon2> MODULE IntegerSequence; IMPORT StdLog;

PROCEDURE Do*; VAR i: INTEGER; BEGIN FOR i := 0 TO MAX(INTEGER) DO; StdLog.Int(i) END; StdLog.Ln END Do;

END IntegerSequence. </lang> Execute: ^Q IntegerSequence.Do
Output:

 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 ...

Computer/zero Assembly

This program counts up to 255 in the accumulator, after which it starts again from zero. <lang czasm>start: ADD one

       JMP  start

one: 1</lang>

Cowgol

The largest integer type that Cowgol supports out of the box is the unsigned 32-bit integer. This program will count up to 2^32-1, and then stop.

<lang cowgol>include "cowgol.coh";

var n: uint32 := 1; while n != 0 loop;

   print_i32(n);
   print_nl();
   n := n + 1;

end loop;</lang>

The following program will keep going until it runs out of memory, using one byte per digit.

<lang cowgol>include "cowgol.coh";

sub print_back(s: [uint8]) is

   while [s] != 0 loop;
       print_char([s]);
       s := @prev s;
   end loop;
   print_nl();

end sub;

sub incr(n: [uint8]): (r: [uint8]) is

   r := n;
   while [n] != 0 loop;
       n := @prev n;
   end loop;
   n := @next n; 
   loop
       if [n] == 0 then
           [n] := '1';
           [@next n] := 0;
           r := n;
           break;
       elseif [n] == '9' then
           [n] := '0';
           n := @next n;
           continue;
       else
           [n] := [n] + 1;
           break;
       end if;
   end loop;

end sub;

sub init(n: [uint8]): (r: [uint8]) is

   [n] := 0;
   [n+1] := '0';
   [n+2] := 0;
   r := n+1;

end sub;

var infnum := init(LOMEM); loop

   infnum := incr(infnum);
   print_back(infnum);

end loop;</lang>

Crystal

Will run as long as enough memory to represent numbers. <lang ruby>require "big"

(1.to_big_i ..).each { |i| puts i } </lang>

D

<lang d>import std.stdio, std.bigint;

void main() {

   BigInt i;
   while (true)
       writeln(++i);

}</lang> Alternative: <lang d>import std.stdio, std.traits, std.bigint, std.string;

void integerSequence(T)() if (isIntegral!T || is(T == BigInt)) {

   T now = 1;
   T max = 0;
   static if (!is(T == BigInt))
       max = T.max;

   do
       write(now, " ");
   while (now++ != max);

   writeln("\nDone!");

}

void main() {

   writeln("How much time do you have?");
   writeln(" 0. I'm in hurry.");
   writeln(" 1. I've some time.");
   writeln(" 2. I'm on vacation.");
   writeln(" 3. I'm unemployed...");
   writeln(" 4. I'm immortal!");
   write("Enter 0-4 or nothing to quit: ");

   string answer;
   readf("%s\n", &answer);

   switch (answer.toLower()) {
       case "0": integerSequence!ubyte();  break;
       case "1": integerSequence!short();  break;
       case "2": integerSequence!uint();   break;
       case "3": integerSequence!long();   break;
       case "4": integerSequence!BigInt(); break;
       default: writeln("\nBye bye!");     break;
   }

}</lang>

Dc

DCL

<lang DCL>$ i = 1 $ loop: $ write sys$output i $ i = i + 1 $ goto loop</lang>

Output:

1
2
3
...
2147483646
2147483647
-2147483648
-2147483647
...
-1
0
1
...

Delphi

<lang Delphi>program IntegerSequence;

{$APPTYPE CONSOLE}

var

 i: Integer;

begin

 for i := 1 to High(i) do
   WriteLn(i);

end.</lang>

DWScript

High(i) returns the maximum supported value, typically, it is the highest signed 64 bit integer. <lang delphi> var i: Integer;

for i:=1 to High(i) do

  PrintLn(i);

</lang>

Dyalect

<lang dyalect>var n = 0 while true {

   n += 1
   print(n)

}</lang>

Déjà Vu

<lang dejavu>1

while /= -- dup dup: !. dup ++

drop</lang>

This continues to print numbers until double precision IEEE 754 cannot represent adjacent integers any more (9007199254740992, to be exact).

In the future, the implementation may switch to arbitrary precision, so it will keep running until memory fills up.

E

<lang e>for i in int > 0 { println(i) }</lang>

EchoLisp

<lang scheme> (lib 'bigint) ;; arbitrary length integers (for ((n (in-naturals))) (writeln n)) </lang>

EDSAC order code

<lang edsac>[ Integer sequence

 ================
 
 A program for the EDSAC
 
 Displays integers 1,2,3...
 in binary form in the first
 word of storage tank 2
 until stopped
 
 Works with Initial Orders 2  ]

T56K [ set load point ] GK [ set base address ]

A3@ [ increment accumulator ] U64F [ copy accumulator to 64 ] E@ [ jump to base address ]

P0D [ constant: 1 ]

EZPF [ begin at load point ]</lang>

Eiffel

<lang eiffel> class APPLICATION inherit ARGUMENTS create make feature {NONE} -- Initialization make -- Run application. do from number := 0 until number = number.max_value loop print(number) print(", ") number := number + 1 end end number:INTEGER_64 end </lang>

Elena

ELENA 4.x : <lang elena>import extensions;

public program() {

   var i := 0u;
   while (true)
   {
       console.printLine(i);

       i += 1u
   }

}</lang>

Elixir

<lang elixir>Stream.iterate(1, &(&1+1)) |> Enum.each(&(IO.puts &1))</lang>

Emacs Lisp

Displays in the message area interactively, or to standard output under -batch.

<lang lisp>(dotimes (i most-positive-fixnum)

 (message "%d" (1+ i)))</lang>

Erlang

<lang erlang> F = fun(FF, I) -> io:format("~p~n", [I]), FF(FF, I + 1) end, F(F,0). </lang>

ERRE

<lang> ............. A%=0 LOOP

 A%=A%+1
 PRINT(A%;)

END LOOP ............. </lang> % is integer-type specificator. Integer type works on 16-bit signed numbers (reserved constant MAXINT is 32767). Beyond this limit execution will give Runtime error #6 (overflow).

Euphoria

<lang euphoria>integer i i = 0 while 1 do

   ? i
   i += 1

end while</lang>

F#

<lang fsharp>// lazy sequence of integers starting with i let rec integers i =

 seq { yield i
       yield! integers (i+1) }

Seq.iter (printfn "%d") (integers 1)</lang>

lazy sequence of int32 starting from 0 <lang fsharp>let integers = Seq.initInfinite id</lang>

lazy sequence of int32 starting from n <lang fsharp>let integers n = Seq.initInfinite ((+) n)</lang>

lazy sequence (not necessarily of int32) starting from n (using unfold anamorphism) <lang fsharp>let inline numbers n =

   Seq.unfold (fun n -> Some (n, n + LanguagePrimitives.GenericOne)) n</lang>

> numbers 0 |> Seq.take 10;;
val it : seq<int> = seq [0; 1; 2; 3; ...]
> let bignumber = 12345678901234567890123456789012345678901234567890;;
val bignumber : System.Numerics.BigInteger =
  12345678901234567890123456789012345678901234567890
> numbers bignumber |> Seq.take 10;;
val it : seq<System.Numerics.BigInteger> =
 seq
   [12345678901234567890123456789012345678901234567890 {IsEven = true;
                                                        IsOne = false;
                                                        IsPowerOfTwo = false;
                                                        IsZero = false;
                                                        Sign = 1;};
    12345678901234567890123456789012345678901234567891 {IsEven = false;
                                                        IsOne = false;
                                                        IsPowerOfTwo = false;
                                                        IsZero = false;
                                                        Sign = 1;};
    12345678901234567890123456789012345678901234567892 {IsEven = true;
                                                        IsOne = false;
                                                        IsPowerOfTwo = false;
                                                        IsZero = false;
                                                        Sign = 1;};
    12345678901234567890123456789012345678901234567893 {IsEven = false;
                                                        IsOne = false;
                                                        IsPowerOfTwo = false;
                                                        IsZero = false;
                                                        Sign = 1;}; ...]
> numbers 42.42 |> Seq.take 10;;
val it : seq<float> = seq [42.42; 43.42; 44.42; 45.42; ...]

Factor

<lang factor>USE: lists.lazy 1 lfrom [ . ] leach</lang>

Fantom

<lang fantom> class Main {

 public static Void main()
 {
   i := 1
   while (true)
   {
     echo (i)
     i += 1
   }
 }

} </lang>

Fantom's integers are 64-bit signed, and so the numbers will return to 0 and continue again, if you wait long enough! You can use Java BigInteger via FFI

Fermat

<lang fermat>n:=0; while 1 do !n;!' '; n:=n+1 od</lang>

Fish

Since there aren't really libraries in Fish and I wouldn't know how to program arbitarily large integers, so here's an example that just goes on until the interpreter's number limit: <lang Fish>0>:n1+v

^o" "<</lang>

Forth

<lang forth>: ints ( -- )

 0 begin 1+ dup cr u. dup -1 = until drop ;</lang>

Fortran

Works with: Fortran version 90 and later

<lang fortran>program Intseq

 implicit none
 
 integer, parameter :: i64 = selected_int_kind(18)
 integer(i64) :: n = 1

! n is declared as a 64 bit signed integer so the program will display up to ! 9223372036854775807 before overflowing to -9223372036854775808

 do
   print*, n
   n = n + 1
 end do

end program</lang>

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

' FB does not natively support arbitrarily large integers though support can be added ' by using an external library such as GMP. For now we will just use an unsigned integer (32bit).

Print "Press Ctrl + C to stop the program at any time" Dim i As UInteger = 1

Do

 Print i
 i += 1

Loop Until i = 0 ' will wrap back to 0 when it reaches 4,294,967,296

Sleep</lang>

Frink

All of Frink's numbers can be arbitrarily-sized: <lang Frink> i=0 while true {

  println[i]
  i = i + 1

} </lang>

FunL

The following has no limit since FunL has arbitrary size integers.

Futhark

Infinite loops cannot produce results in Futhark, so this program accepts an input indicating how many integers to generate. It encodes the size of the returned array in its type.

GAP

<lang gap>InfiniteLoop := function() local n; n := 1; while true do Display(n); n := n + 1; od; end;

Prepare some coffee

InfiniteLoop();</lang>

Go

Size of int type is implementation dependent. After the maximum positive value, it rolls over to maximum negative, without error. Type uint will roll over to zero. <lang go>package main

import "fmt"

func main() {

   for i := 1;; i++ {
       fmt.Println(i)
   }

}</lang> The big.Int type does not roll over and is limited only by available memory, or practically, by whatever external factor halts CPU execution: human operator, lightning storm, CPU fan failure, heat death of universe, etc. <lang go>package main

import (

   "big"
   "fmt"

)

func main() {

   one := big.NewInt(1)
   for i := big.NewInt(1);; i.Add(i, one) {
       fmt.Println(i)
   }

}</lang>

Gridscript

INTEGER SEQUENCE.

@width @height 1

(1,1):START (3,1):STORE 1 (5,1):CHECKPOINT 0 (7,1):PRINT (9,1):INCREMENT (11,1):GOTO 0 </lang>

Groovy

<lang groovy>// 32-bit 2's-complement signed integer (int/Integer) for (def i = 1; i > 0; i++) { println i }

// 64-bit 2's-complement signed integer (long/Long) for (def i = 1L; i > 0; i+=1L) { println i }

// Arbitrarily-long binary signed integer (BigInteger) for (def i = 1g; ; i+=1g) { println i }</lang>

GUISS

Graphical User Interface Support Script makes use of installed programs. There are no variables, no loop structures and no jumps within the language so iteration is achieved by repetative instructions. In this example, we will just use the desktop calculator and keep adding one to get a counter. We stop after counting to ten in this example.

<lang guiss>Start,Programs,Accessories,Calculator, Button:[plus],Button:1,Button:[equals],Button:[plus],Button:1,Button:[equals], Button:[plus],Button:1,Button:[equals],Button:[plus],Button:1,Button:[equals], Button:[plus],Button:1,Button:[equals],Button:[plus],Button:1,Button:[equals], Button:[plus],Button:1,Button:[equals],Button:[plus],Button:1,Button:[equals], Button:[plus],Button:1,Button:[equals],Button:[plus],Button:1,Button:[equals]</lang>

GW-BASIC

<lang gwbasic>10 A#=1 20 PRINT A# 30 A#=A#+1 40 GOTO 20</lang>

Haskell

<lang haskell>mapM_ print [1..]</lang>

Or less imperatively:

<lang haskell>putStr $ unlines $ map show [1..]</lang>

HolyC

Prints from 1 to max unsigned 64 bit integer (2**64 -1), then stops. <lang holyc>U64 i = 0; while (++i) Print("%d\n", i); </lang>

Icon and Unicon

Icon and Unicon support large integers by default. The built-in generator seq(i,j) yields the infinite sequence i, i+j, i+2*j, etc. Converting the results to strings for display will likely eat your lunch before the sequence will take its toll.

<lang Icon>procedure main() every write(seq(1)) # the most concise way end</lang>

IS-BASIC

<lang IS-BASIC>100 FOR I=1 TO INF 110 PRINT I; 120 NEXT</lang>

INF = 9.999999999E62

J

The following will count indefinitely but once the 32-bit (or 64-bit depending on J engine version) limit is reached, the results will be reported as floating point values (which would immediately halt on 64 bit J and halt with the 53 bit precision limit is exceeded on 32 bit J). Since that could take many, many centuries, even on a 32 bit machine, more likely problems include the user dying of old age and failing to pay the electric bill resulting in the machine being powered off.

<lang j> count=: (smoutput ] >:)^:_</lang>

The above works with both fixed sized integers and floating point numbers (fixed sized integers are automatically promoted to floating point, if they overflow), but also works with extended precision integers (which will not overflow, unless they get so large that they cannot be represented in memory, but that should exceed lifetime of the universe, let alone lifetime of the computer).

This adds support for extended precision (in that it converts non-extended precision arguments to extended precision arguments) and will display integers to ∞ (or at least until the machine is turned off or interrupted or crashes). <lang j> count=: (smoutput ] >:)@x:^:_</lang>

Java

Long limit: <lang java>public class Count{

   public static void main(String[] args){
       for(long i = 1; ;i++) System.out.println(i);
   }

}</lang> "Forever": <lang java>import java.math.BigInteger;

public class Count{

   public static void main(String[] args){
       for(BigInteger i = BigInteger.ONE; ;i = i.add(BigInteger.ONE)) System.out.println(i);
   }

}</lang>

JavaScript

This code is accurate up to 2^53 where it will be stuck an 2^53 because a IEEE 64-bit double can not represent 2^53 + 1. <lang javascript>var i = 0;

while (true)

   document.write(++i + ' ');</lang>

This example uses a BigInt[1] literal to support arbitrary large integers. <lang javascript>var i = 0n;

while (true)

   document.write(++i + ' ');</lang>

Joy

<lang joy> 1 [0 >] [dup put succ] while pop.</lang>

Counting stops at maxint, which is 2147483647

jq

Currently, jq does not support infinite-precision arithmetic, but very large integers are converted to floating-point numbers, so the following will continue to generate integers (beginning with 0) indefinitely in recent versions of jq that have tail recursion optimization: <lang jq>def iota: ., (. + 1 | iota); 0 | iota</lang>In versions of jq which have while, one could also write:<lang jq>0 | while(true;. + 1)</lang>This idiom is likely to be more useful as while supports break.

Another technique would be to use recurse: <lang jq>0 | recurse(. + 1)</lang>For generating integers, the generator, range(m;n), is more likely to be useful in practice; if m and n are integers, it generates integers from m to n-1, inclusive.

Integers can of course also be represented by strings of decimal digits, and if this representation is satisfactory, a stream of consecutive integers thus represented can be generated using the same technique as is employed on the Count_in_octal page.

Julia

<lang julia>i = zero(BigInt) # or i = big(0) while true

 println(i += 1)

end</lang> The built-in BigInt type is an arbitrary precision integer (based on the GMP library), so the value of i is limited only by available memory. To use (much faster) hardware fixed-width integer types, use e.g. zero(Int32) or zero(Int64). (Initializing i = 0 will use fixed-width integers that are the same size as the hardware address width, e.g. 64-bit on a 64-bit machine.)

K

Using a while loop:

<lang k> i:0; while[1;`0:"\n",$i+:1]</lang>

Kotlin

<lang scala>import java.math.BigInteger

// version 1.0.5-2

fun main(args: Array<String>) {

   // print until 2147483647
   (0..Int.MAX_VALUE).forEach { println(it) }

   // print forever
   var n = BigInteger.ZERO
   while (true) {
       println(n)
       n += BigInteger.ONE
   }

}</lang>

Lambdatalk

The long_add primitive allow counting beyond the javascript numbers limits, depending on the system memory. <lang scheme> {def infinite_set

{lambda {:i}
 {if true                                 // will never change
  then :i {infinite_set {long_add :i 1}}  // extends {+ :i 1}
  else You have reached infinity! }}}     // probably never.

-> infinite_set

{infinite_set 0} -> 0 1 2 3 ... forever </lang>

Lang5

Lasso

<lang Lasso>local(number = 1) while(#number > 0) => {^ #number++ ' ' //#number > 100 ? #number = -2 // uncomment this row if you want to halt the run after proving concept ^}</lang> This will run until you exhaust the system resources it's run under.

Liberty BASIC

Liberty BASIC handles extremely large integers. The following code was halted by user at 10,000,000 in test run. <lang lb> while 1

   i=i+1
   locate 1,1
   print i
   scan

wend

</lang>

Limbo

The int (32 bits) and big (64 bits) types are both signed, so they wrap around. This version uses the infinite precision integer library:

<lang Limbo>implement CountToInfinity;

include "sys.m"; sys: Sys; include "draw.m"; include "ipints.m"; ipints: IPints; IPint: import ipints;

CountToInfinity: module { init: fn(nil: ref Draw->Context, nil: list of string); };

init(nil: ref Draw->Context, nil: list of string) { sys = load Sys Sys->PATH; ipints = load IPints IPints->PATH;

i := IPint.inttoip(0); one := IPint.inttoip(1); for(;;) { sys->print("%s\n", i.iptostr(10)); i = i.add(one); } } </lang>

Lingo

<lang lingo>i = 1 repeat while i>0

 put i
 i = i+1

end repeat</lang>

Lingo uses signed 32 bit integers, so max. supported integer value is 2147483647: <lang lingo>put the maxInteger -- 2147483647</lang>

Beyond this limit values behave like negative numbers: <lang lingo>put the maxInteger+1 -- -2147483648 put the maxInteger+2 -- -2147483647</lang>

Up to the (quite high) number where floats (double-precission) start rounding, floats can be used to exceed the integer limit: <lang lingo>the floatPrecision = 0 -- forces floats to be printed without fractional digits

put float(the maxInteger)+1 -- 2147483648

-- max. whole value that can be stored as 8-byte-float precisely maxFloat = power(2,53) -- 9007199254740992.0

i = 1.0 repeat while i<=maxFloat

 put i
 i = i+1

end repeat -- 1 -- 2 -- 3 -- ...</lang>

LLVM

Translation of: C

<lang llvm>; This is not strictly LLVM, as it uses the C library function "printf".

LLVM does not provide a way to print values, so the alternative would be
to just load the string into memory, and that would be boring.

Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps

--- The declarations for the external C functions

declare i32 @printf(i8*, ...)

$"FORMAT_STR" = comdat any @"FORMAT_STR" = linkonce_odr unnamed_addr constant [4 x i8] c"%u\0A\00", comdat, align 1

Function Attrs: noinline nounwind optnone uwtable

define i32 @main() #0 {

 %1 = alloca i32, align 4          ;-- allocate i
 store i32 0, i32* %1, align 4     ;-- store i as 0
 br label %loop

loop:

 %2 = load i32, i32* %1, align 4   ;-- load i
 %3 = add i32 %2, 1                ;-- increment i
 store i32 %3, i32* %1, align 4    ;-- store i
 %4 = icmp ne i32 %3, 0            ;-- i != 0
 br i1 %4, label %loop_body, label %exit

loop_body:

 %5 = load i32, i32* %1, align 4   ;-- load i
 %6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @"FORMAT_STR", i32 0, i32 0), i32 %5)
 br label %loop

exit:

 ret i32 0

}

attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }</lang>

Lua

<lang lua> i = 1

-- in the event that the number inadvertently wraps around, -- stop looping - this is unlikely with Lua's default underlying -- number type (double), but on platform without double -- the C type used for numbers can be changed while i > 0 do

   print( i )
   i = i + 1

end </lang>

M2000 Interpreter

<lang M2000 Interpreter> \\ easy way a=1@ \\ Def statement defines one time (second pass produce error) Rem : Def Decimal a=1 Rem : Def a as decimal=1 \\ Global shadow any global with same name, but not local \\ globals can change type, local can't change \\ to assign value to global need <= \\ Symbol = always make local variables (and shadows globals) Rem : Global a as decimal =1 \\Local make a new local and shadow one with same name Rem : Local a as decimal=1 \\ we can create an "auto rounding" variable \\ an integer with any type (double, single, decimal, currency, long, integer) \\ rounding to .5 : up for positive numbers and down to negative \\ 1.5 round to 2 and -1.5 round to -2 a%=1@

\\ variables a, a%, a$, arrays/functions a(), a$(), sub a() and the module a can exist together \\ A block may act as loop structure using an internal flag \\ A Loop statement mark a flag in the block, so can be anywhere inside, \\ this flag reset to false before restart. {loop : Print a : a++} </lang>

Maple

Maple has arbitrary-precision integers so there are no built-in limits on the size of the integers represented.

<lang Maple>for n do

  print(n)

end do;</lang>

Mathematica / Wolfram Language

Built in arbitrary precision support means the following will not overflow. <lang Mathematica> x = 1; Monitor[While[True, x++], x] </lang>

MATLAB / Octave

<lang Matlab> a = 1; while (1) printf('%i\n',a); a=a+1; end; </lang>

Typically, numbers are stored as double precision floating point numbers, giving accurate integer values up to about 2^53=bitmax('double')=9.0072e+15. Above this limit, round off errors occur. This limitation can be overcome by defining the numeric value as type int64 or uint64

<lang Matlab> a = uint64(1); while (1) printf('%i\n',a); a=a+1; end; </lang>

This will run up to 2^64 and then stop increasing, there will be no overflow.

>> a=uint64(10e16+1)    % 10e16 is first converted into a double precision number causing some round-off error. 
a = 100000000000000000
>> a=uint64(10e16)+1
a = 100000000000000001

The above limitations can be overcome with additional toolboxes for symbolic computation or multiprecision computing.

Matlab and Octave recommend vectorizing the code, one might pre-allocate the sequence up to a specific N.

<lang Matlab> N = 2^30; printf('%d\n', 1:N); </lang>

The main limitation is the available memory on your machine. The standard version of Octave has a limit that a single data structure can hold at most 2^31 elements. In order to overcome this limit, Octave must be compiled with "./configure --enable-64", but this is currently not well supported.

Maxima

min

Works with: min version 0.19.3

min's integers are 64-bit signed. This will eventually overflow. <lang min>0 (dup) () (puts succ) () linrec</lang>

МК-61/52

ML/I

<lang ML/I>MCSKIP "WITH" NL "" Integer sequence "" Will overflow when it reaches implementation-defined signed integer limit MCSKIP MT,<> MCINS %. MCDEF DEMO WITHS NL AS <MCSET T1=1 %L1.%T1. MCSET T1=T1+1 MCGO L1 > DEMO</lang>

Modula-2

<lang modula2>MODULE Sequence; FROM FormatString IMPORT FormatString; FROM Terminal IMPORT WriteString,ReadChar;

VAR

   buf : ARRAY[0..63] OF CHAR;
   i : CARDINAL;

BEGIN

   i := 1;
   WHILE i>0 DO
       FormatString("%c ", buf, i);
       WriteString(buf);
       INC(i)
   END;
   ReadChar

END Sequence.</lang>

Nanoquery

All native integers in Nanoquery can become arbitrarily large by default, so this program would run until it ran out of memory. <lang Nanoquery>i = 1 while true println i i += 1 end</lang>

Necromantus

In Necromantus integer size is limited by the java's int. <lang Necromantus> let i = 0; while true {

   write(i);
   i = i + 1;

} </lang>

NetRexx

Rexx Built In

NetRexx provides built-in support for very large precision arithmetic via the Rexx class. <lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols binary

k_ = Rexx bigDigits = 999999999 -- Maximum setting for digits allowed by NetRexx numeric digits bigDigits

loop k_ = 1

 say k_
 end k_

</lang>

Using BigInteger

Java's BigInteger class is also available for very large precision arithmetic. <lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols binary

import java.math.BigInteger

-- allow an option to change the output radix. parse arg radix . if radix.length() == 0 then radix = 10 -- default to decimal k_ = BigInteger k_ = BigInteger.ZERO

loop forever

 k_ = k_.add(BigInteger.ONE)
 say k_.toString(int radix)
 end

</lang>

NewLISP

<lang NewLISP>(while (println (++ i)))</lang>

Nim

<lang nim>var i:int64 = 0 while true:

   inc i
   echo i</lang>

Using BigInts: <lang nim>import bigints

var i = 0.initBigInt while true:

 i += 1
 echo i</lang>

Oberon-2

Works with oo2c Version 2 <lang oberon2> MODULE IntegerSeq; IMPORT

 Out,
 Object:BigInt;

 PROCEDURE IntegerSequence*;
 VAR
   i: LONGINT;
 BEGIN
   FOR i := 0 TO MAX(LONGINT) DO
     Out.LongInt(i,0);Out.String(", ")
   END;
   Out.Ln
 END IntegerSequence;
 
 PROCEDURE BigIntSequence*;
 VAR
   i: BigInt.BigInt;
 BEGIN
   i := BigInt.zero;
   LOOP
     Out.Object(i.ToString() + ", ");
     i := i.Add(BigInt.one);
   END
 END BigIntSequence;

END IntegerSeq. </lang>

Objeck

<lang objeck> bundle Default {

 class Count {
   function : Main(args : String[]) ~ Nil {
     i := 0;
     do {
       i->PrintLine();
       i += 1;
     } while(i <> 0);
   }
 }

} </lang>

OCaml

with an imperative style: <lang ocaml>let () =

 let i = ref 0 in
 while true do
   print_int !i;
   print_newline ();
   incr i;
 done</lang>

with a functional style: <lang ocaml>let () =

 let rec aux i =
   print_int i;
   print_newline ();
   aux (succ i)
 in
 aux 0</lang>

Oforth

Oforth handles arbitrary integer precision.

The loop will stop when out of memory

<lang Oforth>: integers 1 while( true ) [ dup . 1+ ] ;</lang>

Ol

Ol does not limit the size of numbers. So maximal number depends only on available system memory. <lang scheme> (let loop ((n 1))

  (print n)
  (loop (+ 1 n)))

</lang>

Sample sequence with break for large numbers: <lang scheme> (let loop ((n 2))

  (print n)
  (unless (> n 100000000000000000000000000000000)
     (loop (* n n))))

</lang> Output:

2
4
16
256
65536
4294967296
18446744073709551616
340282366920938463463374607431768211456

OpenEdge/Progress

OpenEdge has three data types that can be used for this task:

INTEGER (32-bit signed integer) <lang progress>DEF VAR ii AS INTEGER FORMAT "->>>>>>>>9" NO-UNDO. DO WHILE TRUE: ii = ii + 1. DISPLAY ii. END.</lang> When an integer rolls over its maximum of 2147483647 error 15747 is raised (Value # too large to fit in INTEGER.).
INT64 (64-bit signed integer) <lang progress>DEF VAR ii AS INT64 FORMAT "->>>>>>>>>>>>>>>>>>9" NO-UNDO. DO WHILE TRUE: ii = ii + 1. DISPLAY ii. END.</lang> When a 64-bit integer overflows no error is raised and the signed integer becomes negative.
DECIMAL (50 digits) <lang progress>DEF VAR de AS DECIMAL FORMAT "->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>9" NO-UNDO. DO WHILE TRUE: de = de + 1. DISPLAY de. END.</lang> When a decimal requires mores than 50 digits error 536 is raised (Decimal number is too large.).

Order

Order supports arbitrarily-large positive integers natively. However, the simple version: <lang c>#include <order/interpreter.h>

define ORDER_PP_DEF_8printloop ORDER_PP_FN( \

8fn(8N, \

   8do(8print(8to_lit(8N) 8comma 8space),   \
       8printloop(8inc(8N)))) )

ORDER_PP( 8printloop(1) )</lang> ... while technically fulfilling the task, will probably never display anything, as most C Preprocessor implementations won't print their output until the file is done processing. Since the C Preprocessor is not technically Turing-complete, the Order interpreter has a maximum number of steps it can execute - but this number is very, very large (from the documentation: "the Order interpreter could easily be extended with a couple of hundred macros to prolong the wait well beyond the estimated lifetime of the sun"), so the compiler is rather more likely to simply run out of memory.

To actually see anything with GCC, add a maximum limit so that the task can complete: <lang c>#include <order/interpreter.h>

define ORDER_PP_DEF_8printloop ORDER_PP_FN( \

8fn(8N, \

   8do(8print(8to_lit(8N) 8comma 8space),   \
       8when(8less(8N, 99), 8printloop(8inc(8N))))) )

ORDER_PP( 8printloop(1) ) // 1, ..., 99,</lang>

PARI/GP

<lang parigp>n=0; while(1,print(++n))</lang>

Pascal

Perl

<lang perl>my $i = 0; print ++$i, "\n" while 1;</lang>

On 64-bit Perls this will get to 2^64-1 then print 1.84467440737096e+19 forever. On 32-bit Perls using standard doubles this will get to 999999999999999 then start incrementing and printing floats until they lose precision. This behavior can be changed by adding something like: <lang perl>use bigint; my $i = 0; print ++$i, "\n" while 1;</lang> which makes almost all integers large (ranges are excluded). Faster alternatives exist with non-core modules, e.g.

use bigint lib=>"GMP";
use Math::Pari qw/:int/;
use Math::GMP qw/:constant/;

Phix

This will crash at 1,073,741,824 on 32 bit, or 4,611,686,018,427,387,904 on 64-bit, and as indicated best not to try this or any below under pwa/p2js:

without javascript_semantics 
integer i = 0
while 1 do
    ?i
    i += 1
end while

This will stall at 9,007,199,254,740,992 on 32-bit, and about twice the above on 64-bit. (after ~15 or 19 digits of precision, adding 1 will simply cease to have any effect)

without javascript_semantics 
atom a = 0
while 1 do
    ?a
    a += 1
end while

Library: Phix/mpfr

This will probably carry on until the number has over 300 million digits (32-bit, you can square that on 64-bit) which would probably take zillions of times longer than the universe has already existed, if your hardware/OS/power grid kept going that long.

without javascript_semantics 
include mpfr.e
mpz b = mpz_init(0)
while true do
    mpz_add_ui(b,b,1) 
    mpfr_printf(1,"%Zd\n",b)
end while

Lastly, a gui version you can run online here.

Library: Phix/pGUI

Library: Phix/online

with javascript_semantics
include pGUI.e
include mpfr.e
Ihandln dlg, lbl
mpz i = mpz_init(0)

function increment()
    mpz_add_ui(i,i,1) 
    IupSetStrAttribute(lbl,"TITLE",mpz_get_str(i))
    return IUP_DEFAULT
end function

IupOpen()
lbl = IupLabel("","PADDING=10x10,EXPAND=YES")
dlg = IupDialog(lbl, "TITLE=Integers,SIZE=160x50")
IupShow(dlg)
IupSetGlobalFunction("IDLE_ACTION",Icallback("increment"))
if platform()!=JS then
    IupMainLoop()
    dlg = IupDestroy(dlg)
    IupClose()
end if

PicoLisp

<lang PicoLisp>(for (I 1 T (inc I))

  (printsp I) )</lang>

Piet

Rendered as a Wiki table because uploading images is not possible.

ww	ww	ww	ww	ww	ww	ww
ww	ww	ww	ww	ww	ww	ww
ww	ww	ww	ww	ww	ww	ww

Program explanation on my user page: [2]

Pike

<lang Pike>int i=1; while(true)

   write("%d\n", i++);</lang>

PILOT

<lang pilot>C :n = 1

InfiniteLoop

T :#n C :n = n + 1 J :*InfiniteLoop</lang>

PL/I

<lang PL/I> infinity: procedure options (main);

  declare k fixed decimal (30);
  put skip edit
     ((k do k = 1 to 999999999999999999999999999998))(f(31));

end infinity; </lang>

PL/M

PL/M natively supports two integer types, named BYTE and ADDRESS. ADDRESS is a 16-bit integer, so it can count up to 65536. The following program will print numbers until the ADDRESS variable overflows.

<lang plm>100H:

/* CP/M CALL AND NUMBER OUTPUT ROUTINE */ BDOS: PROCEDURE (FN, ARG);

   DECLARE FN BYTE, ARG ADDRESS;
   GO TO 5;

END BDOS;

PRINT: PROCEDURE (STR);

   DECLARE STR ADDRESS;
   CALL BDOS(9, STR);

END PRINT;

PRINT$NUMBER: PROCEDURE (N);

   DECLARE S (8) BYTE INITIAL ('.....',13,10,'$');
   DECLARE (N, P) ADDRESS, C BASED P BYTE;
   P = .S(5);

DIGIT:

   P = P - 1;
   C = N MOD 10 + '0';
   N = N / 10;
   IF N > 0 THEN GO TO DIGIT;
   CALL PRINT(P);

END PRINT$NUMBER;

/* PRINT NUMBERS UNTIL ADDRESS VARIABLE OVERFLOWS */ DECLARE N ADDRESS INITIAL (1); DO WHILE N <> 0;

   CALL PRINT$NUMBER(N);
   N = N + 1;

END;

CALL BDOS(0,0); EOF</lang>

To get around this limitation, the following program stores the number as an array of digits. It will keep going until it runs out of memory (and then it will crash). On a 64K CP/M system it will keep going until it has over 50.000 digits.

<lang plm>100H:

/* CP/M CALL */ BDOS: PROCEDURE (FN, ARG);

   DECLARE FN BYTE, ARG ADDRESS;
   GO TO 5;

END BDOS;

PUT$CHAR: PROCEDURE (CHAR);

   DECLARE CHAR BYTE;
   CALL BDOS(2, CHAR);

END PUT$CHAR;

/* PRINT STRING BACKWARDS UNTIL ZERO */ PRINT$BACK: PROCEDURE (S);

   DECLARE S ADDRESS, C BASED S BYTE;
   DO WHILE C <> 0;
       CALL PUT$CHAR(C);
       S = S - 1;
   END;
   CALL PUT$CHAR(13);
   CALL PUT$CHAR(10);

END PRINT$BACK;

/* INCREMENT NUMBER STORED AS ASCII DIGITS */ INCR$BIGINT: PROCEDURE (BI) ADDRESS;

   DECLARE (BI, R) ADDRESS, D BASED BI BYTE;
   R = BI;
   DO WHILE D <> 0; BI = BI - 1; END;

INCR$DIGIT:

   BI = BI + 1;
   IF D = 0 THEN DO;
       D = '1';
       D(1) = 0;
       RETURN BI;
   END;
   ELSE IF D = '9' THEN DO;
       D = '0';
       GO TO INCR$DIGIT;
   END;
   ELSE DO;
       D = D + 1;
       RETURN R;
   END;

END INCR$BIGINT;

/* STORE INITIAL 'BIG INTEGER' */ INIT$BIGINT: PROCEDURE (X) ADDRESS;

   DECLARE X ADDRESS, D BASED X BYTE;
   D(0) = 0;
   D(1) = '0';
   D(2) = 0;
   RETURN .D(1);

END INIT$BIGINT;

/* LOOP PRINTING NUMBERS FOREVER */ DECLARE I ADDRESS; I = INIT$BIGINT(.MEMORY); DO WHILE 1;

   I = INCR$BIGINT(I);
   CALL PRINT$BACK(I);

END;

EOF</lang>

Plain English

Numbers are signed 32-bit values, so this will overflow somewhere in the neighborhood of 2.1 billion. <lang plainenglish>To run: Start up. Put 1 into a number. Loop. Convert the number to a string. Write the string to the console. Bump the number. Repeat. Shut down.</lang>

PostScript

Library: initlib

PowerShell

<lang Powershell>try {

   for ([int]$i = 0;;$i++)
   {
       $i
   }

} catch {break}</lang>

Prolog

<lang Prolog>loop(I) :- writeln(I), I1 is I+1, loop(I1). </lang>

Constraint Handling Rules

Works with SWI-Prolog and library CHR written by Tom Schrijvers and Jan Wielemaker <lang Prolog>:- use_module(library(chr)).

- chr_constraint loop/1.

loop(N) <=> writeln(N), N1 is N+1, loop(N1). </lang>

PureBasic

<lang PureBasic>OpenConsole() Repeat

 a.q+1
 PrintN(Str(a))

ForEver</lang>

Python

<lang python>i=1 while i:

   print(i)
   i += 1</lang>

Or, alternatively: <lang python>from itertools import count

for i in count():

   print(i)</lang>

Pythons integers are of arbitrary large precision and so programs would probably keep going until OS or hardware system failure.

Q

Translation of: K

Using converge (the \ adverb): <lang q>({-1 string x; x+1}\) 1</lang>

Using while: <lang q>i:0; while[1;-1 string (i+:1)]</lang>

Quackery

Quackery uses bignums.

<lang Quackery>0 [ 1+ dup echo cr again ]</lang>

R

Racket

Racket uses bignums, so counting should continue up to very large numbers. Naturally, printing these numbers will consume quite a bit of power.

<lang Racket>#lang racket (for ([i (in-naturals)]) (displayln i)) </lang>

Raku

(formerly Perl 6) <lang perl6>.say for 1..*</lang>

Raven

Raven uses signed 32 bit integer values. <lang Raven>1 as $i repeat TRUE while

  $i "%d\n" print   $i 1000 +  as $i</lang>

Red

<lang rebol>Red ["Integer sequence"]

i: 1 forever [

   print i
   i: i + 1

]</lang>

Retro

Retro uses signed integer values.

<lang Retro>#0 [ [ n:put spa ] sip n:inc dup n:-zero? ] while drop</lang>

REXX

<lang rexx>/*count all the protons, electrons, & whatnot in the universe, and then */ /*keep counting. According to some pundits in-the-know, one version of */ /*the big-bang theory is that the universe will collapse back to where */ /*it started, and this computer program will be still counting. */ /*┌────────────────────────────────────────────────────────────────────┐

 │ Count all the protons  (and electrons!)  in the universe, and then │
 │ keep counting.  According to some pundits in-the-know, one version │
 │ of the big-bang theory is that the universe will collapse back to  │
 │ where it started, and this computer program will still be counting.│
 │                                                                    │
 │                                                                    │
 │ According to Sir Arthur Eddington in 1938 at his Tamer Lecture at  │
 │ Trinity College (Cambridge), he postulated that there are exactly  │
 │                                                                    │
 │                              136 ∙ 2^256                           │
 │                                                                    │
 │ protons in the universe and the same number of electrons, which is │
 │ equal to around  1.57477e+79.                                      │
 │                                                                    │
 │ Although, a modern estimate is around  10^80.                      │
 │                                                                    │
 │                                                                    │
 │ One estimate of the age of the universe is  13.7  billion years,   │
 │ or  4.32e+17 seconds.    This'll be a piece of cake.               │
 └────────────────────────────────────────────────────────────────────┘*/

numeric digits 1000000000 /*just in case the universe slows down. */

                               /*this version of a DO loop increments J*/
        do j=1                 /*Sir Eddington's number, then a googol.*/
        say j                  /*first, destroy some electrons.        */
        end

say 42 /*(see below for explanation of 42.) */ exit

/*This REXX program (as it will be limited to the NUMERIC DIGITS above, */ /*will only count up to 1000000000000000000000000000000000000000000... */ /*000000000000000000000000000000000000000000000000000000000000000000000 */ /* ... for another (almost) one billion more zeroes (then subtract 1).*/

/*if we can count 1,000 times faster than the fastest PeeCee, and we */ /*started at the moment of the big-bang, we'd be at only 1.72e+28, so */ /*we still have a little ways to go, eh? */

/*To clarify, we'd be 28 zeroes into a million zeroes. If PC's get */ /*1,000 times faster again, that would be 31 zeroes into a million. */

/*It only took Deep Thought 7.5 million years to come up with the */ /*answer to everything (and it double-checked the answer). It was 42.*/</lang>

Ring

<lang ring> size = 10

for n = 1 to size

   see n + nl

next see nl

for n in [1:size]

   see n + nl

next see nl

i = n while n <= size

     see n + nl
     n = n + 1

end </lang>

Ruby

The step method of Numeric takes two optional arguments. The limit defaults to infinity, the step size to 1. Ruby does not limit the size of integers.

Ruby 2.6 introduced open-ended ranges:

Run BASIC

<lang runbasic>while 1 i = i + 1 print i wend</lang> Eventually as it gets larger it becomes a floating point.

Rust

Works with: Rust 1.2

<lang rust>fn main() {

   for i in 0.. {
       println!("{}", i);
   }

}</lang>

Looping endlessly: <lang rust>extern crate num;

use num::bigint::BigUint; use num::traits::{One,Zero};

fn main() {

   let mut i: BigUint = BigUint::one();
   loop {
       println!("{}", i);
       i = i + BigUint::one();
   }

}</lang>

Salmon

Salmon has built-in unlimited-precision integer arithmetic, so these examples will all continue printing decimal values indefinitely, limited only by the amount of memory available (it requires O(log(n)) bits to store an integer n, so if your computer has 1 GB of memory, it will count to a number with on the order of $2^{80}$ digits).

<lang Salmon>iterate (i; [0...+oo])

   i!;</lang>

or

<lang Salmon>for (i; 0; true)

   i!;</lang>

or

<lang Salmon>variable i := 0; while (true)

 {
   i!;
   ++i;
 };</lang>

Scala

<lang scala>Stream from 1 foreach println</lang>

Scheme

<lang scheme> (let loop ((i 1))

 (display i) (newline)
 (loop (+ 1 i)))

</lang>

Scheme does not limit the size of numbers.

Seed7

Limit 2147483647: <lang seed7>$ include "seed7_05.s7i";

 const proc: main is func
   local
     var integer: number is 0;
   begin
     repeat
       incr(number);
       writeln(number);
     until number = 2147483647;
   end func;</lang>

"Forever": <lang seed7>$ include "seed7_05.s7i";

 include "bigint.s7i";

 const proc: main is func
   local
     var bigInteger: number is 1_;
   begin
     repeat
       writeln(number);
       incr(number);
     until FALSE;
   end func;</lang>

Sidef

No limit: <lang ruby>{|i| say i } * Math.inf;</lang>

Smalltalk

<lang smalltalk>i := 0. [

  Stdout print:i; cr.
  i := i + 1

] loop</lang> will run forever.

SSEM

Since we have no Add instruction, we subtract -1 on each iteration instead of adding 1. The same -1 also serves as a jump target, taking advantage of a quirk of the SSEM architecture (the Current Instruction counter is incremented after the instruction has been executed, not before—so GOTO address has to be coded as GOTO address - 1). <lang ssem>01000000000000010000000000000000 0. Sub. 2 acc -= -1 01000000000000000000000000000000 1. 2 to CI goto -1 + 1 11111111111111111111111111111111 2. -1</lang>

Standard ML

This will print up to Int.maxInt and then raise an Overflow exception. On a 32 bit machine the max is 1073741823. Alternatively you could use Int64.int (64 bit) or IntInf.int (arbitrary precision).

<lang sml>let

 fun printInts(n) = 
   (		
     print(Int.toString(n) ^ "\n");
     printInts(n+1)
   )

in

 printInts(1)

end;</lang>

Output:

1
2
3
...
1073741821
1073741822
1073741823

uncaught exception Overflow [overflow]
  raised at: <file intSeq.sml>

SuperCollider

The SuperCollider language has a 32-bit signed int, and a 64 bit signed float. Instead of locking the interpreter with an infinite loop, we post the values over time. <lang SuperCollider> i = Routine { inf.do { |i| i.yield } }; // return all integers, represented by a 64 bit signed float. fork { inf.do { i.next.postln; 0.01.wait } }; // this prints them incrementally </lang>

A shorter form of the first line above, using list comprehensions: <lang SuperCollider> i = {:i, i<-(0..) }; </lang>

Swift

<lang Swift>var i = 0 while true {

   println(i++)

}</lang>

Symsyn

<lang Symsyn> | The following code will run forever | Symsyn uses a 64 bit signed integer | The largest positive integer is 9223372036854775807 | lpi + 1 = -9223372036854775808

lp

x  []
+ x
go lp

</lang>

Tcl

<lang tcl>package require Tcl 8.5 while true {puts [incr i]}</lang>

Tiny BASIC

   REM will overflow after 32767
   LET N = 0

10 PRINT N

   LET N = N + 1
   GOTO 10

</lang>

True BASIC

<lang qbasic>LET i = 0

DO

  PRINT i
  LET i = i + 1

LOOP

END</lang>

TUSCRIPT

<lang tuscript>$$ MODE TUSCRIPT LOOP n=0,999999999 n=n+1 ENDLOOP</lang>

UNIX Shell

<lang sh>#!/bin/sh num=0 while true; do

 echo $num
 num=`expr $num + 1`

done</lang>

Ursa

<lang ursa>#

integer sequence

declare an int and loop until it overflows

decl int i set i 1 while true

       out i endl console
       inc i

end while</lang>

Vala

<lang vala> uint i = 0; while (++i < uint.MAX) stdout.printf("%u\n", i); </lang>

Verilog

<lang Verilog>module main;

 integer  i;

 initial begin
   i = 1;

   while(i > 0) begin
       $display(i);
       i = i + 1;
   end 
 $finish ;
 end

endmodule</lang>

Visual Basic .NET

Visual Basic .NET supports an unsigned, 64 bit Integer (maxing out at a whopping 9 223 372 036 854 775 807), however, this is not an intrinsic type, it is a structure that is not supported by the CLS (Common Language Specification).

The CLS supported type (also a structure) is Decimal (an even more impressive range from positive 79 228 162 514 264 337 593 543 950 335 to negative 79 228 162 514 264 337 593 543 950 335), I have used a standard CLS Integer intrinsic type (from -2 147 483 648 through 2 147 483 647).

Note that attempting to store any value larger than the maximum value of any given type (say 2 147 483 648 for an Integer) will result in an OverflowException being thrown ("Arithmetic operation resulted in an overflow.")

<lang vbnet> For i As Integer = 0 To Integer.MaxValue

     Console.WriteLine(i)
   Next</lang>

Arbitrarily large numbers

One could use the System.Numerics library as the C# example did, or one can do the following.
A list of Long Integers is maintained as the incremented number. As the incremented value approaches the maximum allowed (base) in the first element of ar, a new item is inserted at the beginning of the list to extend the incremented number. The process has the limitation of when the ar array is enlarged to the point where the program exhausts the available memory, it ought to indicate failure and terminate. It is my understanding that a List count is backed by an Integer.MaxValue limitation and there may also be a 2 GB per object limitation involved. Since writing to the Console is such a slow process, I lack the patience to wait for the program (as written) to fail. If the program is tweaked to fail early, the practical limit seems to be a number 2,415,919,086 digits in length. <lang vbnet>Imports System.Console

Module Module1

   Dim base, b1 As Long, digits As Integer, sf As String, st As DateTime,
       ar As List(Of Long) = {0L}.ToList, c As Integer = ar.Count - 1

   Sub Increment(n As Integer)
       If ar(n) < b1 Then
           ar(n) += 1
       Else
           ar(n) = 0 : If n > 0 Then
               Increment(n - 1)
           Else
               Try
                   ar.Insert(0, 1L) : c += 1
               Catch ex As Exception
                   WriteLine("Failure when trying to increase beyond {0} digits", CDbl(c) * digits)
                   TimeStamp("error")
                   Stop
               End Try
           End If
       End If
   End Sub

   Sub TimeStamp(cause As String)
       With DateTime.Now - st
           WriteLine("Terminated by {5} at {0} days, {1} hours, {2} minutes, {3}.{4} seconds",
                     .Days, .Hours, .Minutes, .Seconds, .Milliseconds, cause)
       End With
   End Sub

   Sub Main(args As String())
       digits = Long.MaxValue.ToString.Length - 1
       base = CLng(Math.Pow(10, digits)) : b1 = base - 1
       base = 10 : b1 = 9
       sf = "{" & base.ToString.Replace("1", "0:") & "}"
       st = DateTime.Now
       While Not KeyAvailable
           Increment(c) : Write(ar.First)
           For Each item In ar.Skip(1) : Write(sf, item) : Next : WriteLine()
       End While
       TimeStamp("keypress")
   End Sub

End Module</lang>

Output:

1
2
3
...
10267873
10267874
10267875
Terminated by keypress at 0 days, 0 hours, 30 minutes, 12.980 seconds

WDTE

<lang WDTE>let s => import 'stream';

s.new 0 (+ 1) -> s.map (io.writeln io.stdout) -> s.drain

</lang>

WDTE's number type is, at the time of writing, backed by Go's float64 type, so all of the same limitations that apply there apply here. Also, this should not be run in the WDTE playground, as it will run with no output until the browser crashes or is killed.

Wren

Library: Wren-fmt

Library: Wren-big

In Wren all numbers are stored in 64-bit floating point form. This means that precise integer calculations are only possible within a maximum absolute magnitude of 2^53-1 (16 digits) unless one uses the Wren-big module whose BigInt class can deal with integers of arbitrary size.

Also, the System.print method in the standard library will only display a maximum of 14 digits before switching to scientific notation. To get around this one can use instead the Fmt.print method of the Wren-fmt module which displays integers 'normally' up to the maximum and also caters for BigInts as well. <lang ecmascript>import "./fmt" for Fmt import "./big" for BigInt

var max = 2.pow(53) // 9007199254740992 (16 digits) for (i in 1...max) Fmt.print("$d", i)

var bi = BigInt.new(max.toString) while (true) {

   Fmt.print("$i", bi)
   bi = bi + 1

}</lang>

XLISP

<lang lisp>(defun integer-sequence-from (x) (print x) (integer-sequence-from (+ x 1)) )

(integer-sequence-from 1)</lang>

XPL0

<lang XPL0>\Displays integers up to 2^31-1 = 2,147,483,647 code CrLf=9, IntOut=11; int N; [N:= 1; repeat IntOut(0, N); CrLf(0);

       N:= N+1;

until N<0; ]</lang>

Yabasic

<lang yabasic>i = 1

repeat

   print i
   i = i + 1

until i = 0 end</lang>

Z80 Assembly

The Amstrad CPC's screen isn't big enough to show it all at once, but here you go. This prints numbers out (in hexadecimal) from 0x0001 to 0xFFFF. <lang z80>org &1000 PrintChar equ &BB5A ld hl,1 ;START AT ONE main: push hl

PRINT HIGH BYTE

ld a,h call ShowHex

THEN PRINT LOW BYTE

ld a,l call ShowHex

NEW LINE

ld a,13 call PrintChar ld a,10 call PrintChar

pop hl

NEXT HL

inc hl

COMPARE HL TO ZERO

ld a,h or l jr nz,main ;IF NOT ZERO, REPEAT ret ;RETURN TO BASIC

ShowHex: push af and %11110000 rrca rrca rrca rrca call PrintHexChar pop af and %00001111 ;call PrintHexChar ;execution flows into it naturally. PrintHexChar:

       ;this converts hexadecimal to ascii.

or a ;Clear Carry Flag daa add a,&F0 adc a,&40 jp PrintChar ;ret</lang>

zkl

<lang zkl>[1..].pump(Console.println) // eager m:=(1).MAX; [1..m].pump(Console.println) // (1).MAX is 9223372036854775807 [1..].pump(100,Console.println) // lazy</lang>