% 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


```euphoria
integer i
i = 0
while 1 do
    ? i
    i += 1
end while

=={{header|F_Sharp|F#}}==

// lazy sequence of integers starting with i
let rec integers i =
  seq { yield i
        yield! integers (i+1) }

Seq.iter (printfn "%d") (integers 1)

lazy sequence of int32 starting from 0

lazy sequence of int32 starting from n

```fsharp
let integers n = Seq.initInfinite ((+) n)

lazy sequence (not necessarily of int32) starting from n (using unfold anamorphism)

let inline numbers n =
    Seq.unfold (fun n -> Some (n, n + LanguagePrimitives.GenericOne)) n

Factor

USE: lists.lazy
1 lfrom [ . ] leach

Fantom

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

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

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:

:n1+v
 ^o" "<

Forth

: ints ( -- )
  0 begin 1+ dup cr u. dup -1 = until drop ;

Fortran

{{works with|Fortran|90 and later}}

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

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

Frink

All of Frink's numbers can be arbitrarily-sized:

i=0
while true
{
   println[i]
   i = i + 1
}

FunL

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

for i <- 1.. do println( i )

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.

fun main(n: int): [n]int = iota n

GAP

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

# Prepare some coffee
InfiniteLoop();

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.

package main

import "fmt"

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

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.

package main

import (
    "big"
    "fmt"
)

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

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

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 }

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.

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]

Haskell

mapM_ print [1..]

Or less imperatively:

putStr $ unlines $ map show [1..]

=={{header|Icon}} and {{header|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.

procedure main()
every write(seq(1))        # the most concise way
end

=={{header|IS-BASIC}}== 100 FOR I=1 TO INF 110 PRINT I; 120 NEXT

INF = 9.999999999E62


## HolyC

Prints from 1 to max unsigned 64 bit integer (2**64 -1), then stops.

```holyc
U64 i = 0;
while (++i) Print("%d\n", i);

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.

 count=: (smoutput ] >:)^:_

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).

 count=: (smoutput ] >:)@x:^:_

Java

Long limit:

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

"Forever":

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);
    }
}

JavaScript

var i = 0;

while (true)
    document.write(++i + ' ');

Joy

1 [0 >] [dup put succ] while pop.

Counting stops at maxint, which is 2147483647

jq

Currently, julia 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:

def iota: ., (. + 1 | iota);
0 | iota

In versions of jq which have while, one could also write:

0 | while(true;. + 1)

This idiom is likely to be more useful as while supports break.

Another technique would be to use recurse:

0 | recurse(. + 1)

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.

Julia

i = zero(BigInt)    # or i = big(0)
while true
  println(i += 1)
end

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

  {`0:"\n",$x+:1;x}/1

Using a while loop:

  i:0; while[1;`0:"\n",$i+:1]

Kotlin

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
    }
}

Lang5

## Lasso


```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
^}

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.

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

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:

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);
	}
}

Lingo

i = 1
repeat while i>0
  put i
  i = i+1
end repeat

Lingo uses signed 32 bit integers, so max. supported integer value is 2147483647:

put the maxInteger
-- 2147483647

Beyond this limit values behave like negative numbers:

put the maxInteger+1
-- -2147483648
put the maxInteger+2
-- -2147483647

Up to the (quite high) number where floats (double-precission) start rounding, floats can be used to exceed the integer limit:

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
-- ...

LLVM

{{trans|C}}

; 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" }

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

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++}

Maple

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

for n do
   print(n)
end do;

=={{header|Mathematica}} / {{header|Wolfram Language}}== Built in arbitrary precision support meanst the following will not overflow.

x = 1;
Monitor[While[True, x++], x]

=={{header|MATLAB}} / {{header|Octave}}==

 a = 1; while (1) printf('%i\n',a); a=a+1; end;

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

 a = uint64(1); while (1) printf('%i\n',a); a=a+1; end;

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.

  N = 2^30; printf('%d\n', 1:N);

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

for i do disp(i);

min

{{works with|min|0.19.3}} min's integers are 64-bit signed. This will eventually overflow.

0 (dup) () (puts succ) () linrec

=={{header|МК-61/52}}== 1 П4 ИП4 С/П КИП4 БП 02

## ML/I


```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

=={{header|Modula-2}}==

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.

NetRexx

Rexx Built In

NetRexx provides built-in support for very large precision arithmetic via the Rexx class.

/* 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_

Using BigInteger

Java's BigInteger class is also available for very large precision arithmetic.

/* 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

NewLISP

(while (println (++ i)))

Nim

var i:int64 = 0
while true:
    inc i
    echo i

Using BigInts:

import bigints

var i = 0.initBigInt
while true:
  i += 1
  echo i

=={{header|Oberon-2}}== Works with oo2c Version 2

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.

Objeck

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

OCaml

with an imperative style:

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

with a functional style:

let () =
  let rec aux i =
    print_int i;
    print_newline ();
    aux (succ i)
  in
  aux 0

Oforth

Oforth handles arbitrary integer precision.

The loop will stop when out of memory

: integers  1 while( true ) [ dup . 1+ ] ;

Ol

Ol does not limit the size of numbers. So maximal number depends only on available system memory.

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

Sample sequence with break for large numbers:

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

Output:

2
4
16
256
65536
4294967296
18446744073709551616
340282366920938463463374607431768211456

OpenEdge/Progress

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

1. INTEGER (32-bit signed integer)

   DEF VAR ii AS INTEGER FORMAT "->>>>>>>>9" NO-UNDO.
   
   DO WHILE TRUE:
      ii = ii + 1.
      DISPLAY ii.
   END.
   

   When an integer rolls over its maximum of 2147483647 error 15747 is raised (Value # too large to fit in INTEGER.).

2. INT64 (64-bit signed integer)

   DEF VAR ii AS INT64 FORMAT "->>>>>>>>>>>>>>>>>>9" NO-UNDO.
   
   DO WHILE TRUE:
      ii = ii + 1.
      DISPLAY ii.
   END.
   

   When a 64-bit integer overflows no error is raised and the signed integer becomes negative.

3. DECIMAL (50 digits)

   DEF VAR de AS DECIMAL FORMAT "->>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>9" NO-UNDO.
   
   DO WHILE TRUE:
      de = de + 1.
      DISPLAY de.
   END.
   

   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:

#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) )

... 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:

#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,

PARI/GP

n=0; while(1,print(++n))

Pascal

See also [[Integer_sequence#Delphi | Delphi]] {{works with|Free_Pascal}} Quad word has the largest positive range of all ordinal types

Program IntegerSequenceLimited;
var
  Number: QWord = 0; // 8 bytes, unsigned: 0 .. 18446744073709551615
begin
  repeat
    writeln(Number);
    inc(Number);
  until false;
end.

{{libheader|GMP}} With the gmp library your patience is probably the limit :-)

Program IntegerSequenceUnlimited;

uses
  gmp;

var
  Number: mpz_t;

begin
  mpz_init(Number); //* zero now *//
  repeat
    mp_printf('%Zd' + chr(13) + chr(10), @Number);
    mpz_add_ui(Number, Number, 1); //* increase Number *//
  until false;
end.

Perl

my $i = 0;
print ++$i, "\n" while 1;

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:

use bigint;
my $i = 0;  print ++$i, "\n" while 1;

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/;

Perl 6

.say for 1..*

Phix

This will crash at 1,073,741,824 on 32 bit, 4,611,686,018,427,387,904 on 64-bit:

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)

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

{{libheader|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.

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

PicoLisp

(for (I 1 T (inc I))
   (printsp I) )

Piet

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

{| style="border-collapse: collapse; border-spacing: 0; font-family: courier-new,courier,monospace; font-size: 18px; line-height: 1.2em; padding: 0px" | style="background-color:#ffc0c0; color:#ffc0c0;" | ww | style="background-color:#ff0000; color:#ff0000;" | ww | style="background-color:#c0ffc0; color:#c0ffc0;" | ww | style="background-color:#ffc0c0; color:#ffc0c0;" | ww | style="background-color:#ff00ff; color:#ff00ff;" | ww | style="background-color:#ff00ff; color:#ff00ff;" | ww | style="background-color:#c000c0; color:#c000c0;" | ww |-

| style="background-color:#000000; color:#000000;" | ww | style="background-color:#000000; color:#000000;" | ww | style="background-color:#0000ff; color:#0000ff;" | ww | style="background-color:#ff00ff; color:#ff00ff;" | ww | style="background-color:#ff00ff; color:#ff00ff;" | ww | style="background-color:#ff00ff; color:#ff00ff;" | ww | style="background-color:#00c0c0; color:#00c0c0;" | ww |-

| style="background-color:#000000; color:#000000;" | ww | style="background-color:#000000; color:#000000;" | ww | style="background-color:#0000ff; color:#0000ff;" | ww | style="background-color:#0000ff; color:#0000ff;" | ww | style="background-color:#00c0c0; color:#00c0c0;" | ww | style="background-color:#00ffff; color:#00ffff;" | ww | style="background-color:#0000ff; color:#0000ff;" | ww

|}

Program explanation on my user page: [http://rosettacode.org/wiki/User:Albedo#Integer_Sequence]

PILOT

C  :n = 1
*InfiniteLoop
T  :#n
C  :n = n + 1
J  :*InfiniteLoop

PL/I

infinity: procedure options (main);
   declare k fixed decimal (30);
   put skip edit
      ((k do k = 1 to 999999999999999999999999999998))(f(31));
end infinity;

PostScript

{{libheader|initlib}}

1 {succ dup =} loop

Prolog

loop(I) :-
	writeln(I),
	I1 is I+1,
	loop(I1).

Constraint Handling Rules

Works with SWI-Prolog and library '''CHR''' written by '''Tom Schrijvers''' and '''Jan Wielemaker'''

:- use_module(library(chr)).

:- chr_constraint loop/1.

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

PowerShell

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

PureBasic

OpenConsole()
Repeat
  a.q+1
  PrintN(Str(a))
ForEver

Python

i=1
while i:
    print(i)
    i += 1

Or, alternatively:

from itertools import count

for i in count():
    print(i)

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

Q

{{trans|K}}

Using converge (the </tt> adverb):

({-1 string x; x+1}\) 1

i:0; while[1;-1 string (i+:1)]

z <- 0
repeat {
	print(z)
	z <- z + 1
}

#lang racket
(for ([i (in-naturals)]) (displayln i))

1 as $i
repeat TRUE while
   $i "%d\n" print   $i 1000 +  as $i

#0 [ [ n:put spa ] sip n:inc dup n:-zero? ] while drop

/*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.*/

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

1.step{|n| puts n}

while 1
i = i + 1
print i
wend

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

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();
    }
}

iterate (i; [0...+oo])
    i!;

for (i; 0; true)
    i!;

variable i := 0;
while (true)
  {
    i!;
    ++i;
  };

## Scheme



```scheme

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

$ 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;

$ 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;

{|i| say i } * Math.inf;

i := 0.
[
   Stdout print:i; cr.
   i := i + 1
] loop

01000000000000010000000000000000   0. Sub. 2     acc -= -1
01000000000000000000000000000000   1. 2 to CI    goto -1 + 1
11111111111111111111111111111111   2. -1

i = Routine { inf.do { |i| i.yield } }; // return all integers, represented by a 64 bit signed float.
j = { inf.do { i.next.postln; 0.01.wait } }; // this prints them incrementally
j.play;

var i = 0
while true {
    println(i++)
}

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

1
2
3
...
1073741821
1073741822
1073741823

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

package require Tcl 8.5
while true {puts [incr i]}

$$ MODE TUSCRIPT
LOOP n=0,999999999
n=n+1
ENDLOOP

#!/bin/sh
num=0
while true; do
  echo $num
  num=`expr $num + 1`
done

#
# 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

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

    For i As Integer = 0 To Integer.MaxValue
      Console.WriteLine(i)
    Next

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

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

 import 'stream';

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

(defun integer-sequence-from (x)
	(print x)
	(integer-sequence-from (+ x 1)) )

(integer-sequence-from 1)

\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;
]

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