Integer sequence

Integer sequence
You are encouraged to solve this task according to the task description, using any language you may know.

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.

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

BASIC

<lang basic>5 LET A = 0 10 LET A = A + 1 20 PRINT A 30 GOTO 10</lang>

Works with: QBasic

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

C

<lang c>#include <stdio.h>

1. include <stdint.h>

int main() {

 uint32_t i = 0;
 while (1)
 {
   printf("%u\n", ++i);
 }

 return 0;

}</lang>

Alternatively: <lang c>#include <stdio.h>

1. include <stdint.h>

int main() {

 for (uint32_t i = 1; 1; i++)
   printf("%u\n", i);

 return 0;

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

1. include <cstdint>

int main() {

 uint32_t i = 0;
 while(true)
   std::cout << ++i << std::endl;

 return 0;

}</lang>

Common Lisp

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

D

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

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

   static if(is(T == BigInt)) {
       BigInt now = BigInt(1) ;
       BigInt max = BigInt(0) ;
   } else {
       T now = 1 ;
       T max = T.max ;
   }
   do
       write(now, " ") ;
   while (now++ != max) ;
   writeln("\nDone!") ;

}

void main() {

   string answer ;
   while(answer.length == 0) {
       writeln("Do you have time?") ;
       writeln(" 1. I'm in hurry.") ;
       writeln(" 2. I've some time.") ;
       writeln(" 3. I'm on vacation.") ;
       writeln(" 4. I'm unemployed...") ;
       write(" 0. I'm immortal!\nEnter 0-4 or q for quit > ") ;
       readf("%s\n", &answer) ;
       switch (answer.tolower) {
           case "1": return integerSequence!ubyte ;
           case "2": return integerSequence!short ;
           case "3": return integerSequence!uint ;
           case "4": return integerSequence!long ;
           case "0": return integerSequence!BigInt ;
           case "q": return writeln("Bye bye!") ;
           default:
               writeln("Pardon? try again...") ;
               answer = "" ;
       }
   }

}</lang>

E

<lang e>for i in int > 0 { println(i) }</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>

Haskell

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

Or less imperatively:

<lang haskell>(putStr . unlines . map show) [1..]</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>

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>

Perl

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

Perl 6

<lang perl6>.say for 1..*</lang>

PicoLisp

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

  (printsp I) )</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.

Tcl

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