Loops/Infinite: Difference between revisions

Content added Content deleted

Inline

Revision as of 22:51, 6 January 2020

Task

Print out SPAM followed by a newline in an infinite loop.

Related tasks

360 Assembly

This for sure will result in a severe WTO buffer shortage. <lang 360 Assembly> INFINITE CSECT , this PGM control section INFINITE AMODE 31 addressing mode 31 bit INFINITE RMODE ANY loader can load either 24 or 31

        BAKR  14,0                    stack caller's register contents
        LR    12,15                   establish base 
        LA    13,0                    no savearea 
        USING INFINITE,12             base to assembler 
        LA    10,1                    1 in reg 10 
        LA    11,2                    2 in reg 11

LOOP EQU *

        CR    10,11                   1==2? 
        BE    RETURN                  Yes, exit. 
       WTO    'SPAM',ROUTCDE=11       print SPAM to syslog 
        B     LOOP                    No, check again.

RETURN PR , return to caller

        END   INFINITE

</lang>

4DOS Batch

<lang 4dos>@echo off do forever

 echo SPAM

enddo</lang>

6502 Assembly

Specific OS/hardware routines for printing are left unimplemented. <lang 6502asm>InfiniteLoop LDX #0 PrintLoop: LDA MSG,x JSR PrintAccumulator ;routine not implemented INX CPX #5 BNE PrintLoop BEQ InfiniteLoop

MSG .byte "SPAM", $0A</lang>

6800 Assembly

<lang> .cr 6800

       .tf  spam6800.obj,AP1
       .lf  spam6800

=====================================================;
Infinite SPAM loop for the Motorola 6800 ;
by barrym 2013-04-10 ;
-----------------------------------------------------;
Prints the message "SPAM" repeatedly to an ascii ;
terminal (console) connected to a 1970s vintage ;
SWTPC 6800 system, which is the target device for ;
this assembly. ;
Many thanks to: ;
swtpc.com for hosting Michael Holley's documents! ;
sbprojects.com for a very nice assembler! ;
swtpcemu.com for a very capable emulator! ;
reg x is the string pointer ;
reg a holds the ascii char to be output ;
-----------------------------------------------------;

outeee = $e1d1 ;ROM: console putchar routine

       .or  $0f00

-----------------------------------------------------;

main ldx #string ;Point to the string

       bra  puts       ;  and print it

outs jsr outeee ;Emit a as ascii

       inx             ;Advance the string pointer

puts ldaa ,x ;Load a string character

       bne  outs       ;Print it if non-null
       bra  main       ;else restart

=====================================================;

string .as "SPAM",#13,#10,#0

       .en</lang>

8th

One way: <lang forth>

inf "SPAM\n" . recurse ;

</lang> Another way: <lang forth>

inf repeat "SPAM\n" . again ;

</lang>

ACL2

<lang Lisp>(defun spam ()

  (declare (xargs :mode :program))
  (if nil
      nil
      (prog2$ (cw "SPAM~%")
              (spam))))</lang>

ActionScript

<lang actionscript>while (true) {

   trace("SPAM");

}</lang>

Ada

<lang ada>loop

  Put_Line("SPAM");

end loop;</lang>

Agena

Tested with Agena 2.9.5 Win32 <lang agena>do

   print( "SPAM" )

od</lang>

Aime

<lang aime>while (1) {

   o_text("SPAM\n");

}</lang>

ALGOL 60

Translation of: ALGOL W

Based on the 1962 Revised Repport on ALGOL:

 begin
   integer i;
   for i:=1 step 0 until 2 do 
     outtext("spam")
 end

Works with: ALGOL 60 version OS/360

<lang algol60>'BEGIN' 'COMMENT' Loops/Infinite - Algol60 - 23/06/2018;

 'INTEGER' I;
 'FOR' I := 1 'STEP' 0 'UNTIL' 2 'DO' 
   OUTSTRING(1,'('SPAM')')

'END'</lang>

ALGOL 68

<lang algol68>DO

 printf($"SPAM"l$)

OD</lang> Or the classic "dynamic halt": <lang algol68>loop x:

  printf($"SPAM"l$);

loop x</lang>

ALGOL W

<lang algolw>begin

   for i := 1 step 0 until 2 do write( "SPAM" )

end.</lang>

AmigaE

<lang amigae>PROC main()

 LOOP
   WriteF('SPAM')
 ENDLOOP

ENDPROC</lang>

AppleScript

<lang applescript>repeat

 log "SPAM"

end repeat</lang>

ARM Assembly

<lang ARM_Assembly> .global main

main:

loop:

   ldr r0, =message
   bl printf
   b loop

message:

   .asciz "SPAM\n"

</lang>

ArnoldC

<lang ArnoldC>IT'S SHOWTIME STICK AROUND @NO PROBLEMO TALK TO THE HAND "SPAM" CHILL YOU HAVE BEEN TERMINATED</lang>

Arturo

<lang arturo>loop true { print "SPAM" }</lang>

AutoHotkey

<lang autohotkey>Loop

 MsgBox SPAM `n</lang>

AWK

<lang awk>BEGIN {

 while(1) {
   print "SPAM"
 }

}</lang>

Axe

Warning: running this program will cause you to need to reset your calculator, thereby losing any user data stored in RAM.

<lang axe>While 1

Disp "SPAM",i

End</lang>

BASIC

Works with: QuickBasic version 4.5

Old-fashioned syntax: <lang qbasic>while 1

 print "SPAM"

wend</lang>

Standard BASIC: <lang qbasic>do

 print "SPAM"

loop</lang>

Also <lang qbasic>for i = 1 to 10 step 0

 print "SPAM"

next i</lang>

Works with: Applesoft BASIC

Works with: Commodore BASIC

Works with: ZX Spectrum Basic

10 PRINT "SPAM"
20 GOTO 10

Rather than a GOTO, instead we can use a FOR statement:

10 FOR I = 1 TO 10 STEP 0: REM A zero step makes the loop infinite
20 PRINT "SPAM"
30 NEXT I

Applesoft BASIC

<lang ApplesoftBasic>FOR I = 0 TO 1 STEP 0 : PRINT "SPAM" : NEXT</lang>

IS-BASIC

<lang IS-BASIC>100 DO 110 PRINT "SPAM" 120 LOOP</lang>

Batch File

Using goto: <lang dos>@echo off

loop

echo SPAM goto loop</lang> Another variant which uses Windows NT's for statement:

Works with: Windows NT version 4 or later

<lang dos>for /l %%x in (1,0,2) do @echo SPAM</lang> This essentially is a counted loop which starts at 1, increments by 0 and stops when the counter reaches 2.

BBC BASIC

<lang bbcbasic> REPEAT

       PRINT "SPAM"
     UNTIL FALSE</lang>

bc

<lang bc>while (1) "SPAM "</lang>

beeswax

<lang beeswax>_>`SPA`p

 bN`M`<</lang>

Befunge

Because the 2-D code space is toroidal, all loops are infinite unless explicitly stopped with @. <lang befunge>55+"MAPS",,,,,</lang>

blz

<lang blz>while true

   print("SPAM")

end</lang>

bootBASIC

Using goto: <lang bootBASIC>10 print "SPAM" 20 goto 10</lang>

Using run: <lang bootBASIC>10 print "SPAM" 20 run</lang>

Brainf***

Optimized for code size: <lang bf>++++++++++[->++++++>++++++++>+<<<]>+++++> [+++.---.<.>---.+++>.<]</lang>

Optimized for execution speed: <lang bf>10++++++++++ [-> 8++++++++ > 8++++++++ > 6++++++ > 8++++++++ > 1+ <<<<<]> 83+++ > 80 > 65+++++ > 77--- <<< [.>.>.>.>.<<<<]</lang>

Bracmat

Brat

C

<lang c>while(1) puts("SPAM");</lang> or <lang c> for(;;) puts("SPAM");</lang> or <lang c>do { puts("SPAM"); } while(1);</lang> or <lang c>while(puts("SPAM"));</lang> or <lang c> spam: puts("SPAM"); goto spam; </lang>

ChucK

<lang> while(true) <<<"SPAM">>>; </lang>

C++

Translation of: C

<lang cpp>while (true)

 std::cout << "SPAM\n";</lang>

or <lang cpp>for (;;)

 std::cout << "SPAM\n";</lang>

or <lang cpp>do

 std::cout << "SPAM\n";

while (true);</lang>

C#

<lang csharp>while (true) {

   Console.WriteLine("SPAM");

}</lang>

Chapel

<lang chapel>while true do writeln("SPAM");</lang>

ColdFusion

This will result in a JRun Servlet Error and heap dump.

With tags: <lang cfm><cfloop condition = "true NEQ false">

 SPAM

</cfloop></lang> With script: <lang cfm><cfscript>

 while( true != false )
 {
   writeOutput( "SPAM" );
 }

</cfscript></lang>

Clojure

<lang lisp>(loop [] (println "SPAM") (recur))</lang>

COBOL

<lang cobol> IDENTIFICATION DIVISION.

      PROGRAM-ID. Spam.

      PROCEDURE DIVISION.
          PERFORM UNTIL 1 <> 1
              DISPLAY "SPAM"
          END-PERFORM

          GOBACK
          .</lang>

OpenCOBOL supports a FOREVER clause for PERFORM which will have the same effect.

CoffeeScript

<lang coffeescript>loop

 console.log 'SPAM'

</lang>

Comal

<lang Comal>LOOP

  PRINT "SPAM"

ENDLOOP</lang>

Common Lisp

<lang lisp>(loop (write-line "SPAM"))</lang>

Using DO

<lang lisp> (do () ; Not initialization

   (nil)				; Not break condition
 (print "SPAM"))			; On every loop as requested

</lang>

Output:

"SPAM"
...

D

Some common ways to create an infinite printing loop: <lang d>import std.stdio;

void main() {

   while (true)
       writeln("SPAM");

}</lang>

<lang d>import std.stdio;

void main() {

   do
       writeln("SPAM");
   while (true);

}</lang>

<lang d>import std.stdio;

void main() {

   for ( ; ; )
       writeln("SPAM");

}</lang>

<lang d>import std.stdio;

void main() {

   LOOP:
   writeln("SPAM");
   goto LOOP;

}</lang>

Dart

<lang> main() {

 while(true) {
   print("SPAM");
 }

} </lang>

dc

This loop is a tail-recursive function. The program pushes the function on the stack, the outer dx makes the first call, and the inner dx makes each recursive call.

DCL

<lang DCL>$ loop: $ write sys$output "SPAM" $ goto loop</lang>

Déjà Vu

<lang dejavu>while true: !print "SPAM"</lang> Infinite recursion thanks to tail calls: <lang dejavu>labda: !print "SPAM" recurse call</lang>

Delphi

<lang Delphi>while True do Writeln('SPAM');</lang>

DWScript

<lang Delphi>while True do

  PrintLn('SPAM');</lang>

Dyalect

<lang Dyalect>while true {

   print("SPAM")

}</lang>

E

<lang e>while (true) {

   println("SPAM")

}</lang>

<lang e>def f() {

   println("SPAM")
   f <- ()

} f <- ()</lang>

The difference between these is that in the second, other activities can be interleaved with the loop; in the first, no other processing will occur in this vat.

EDSAC order code

The EDSAC instruction set does not include an unconditional jump: it is necessary to synthesize it by using either an E "branch on accumulator sign bit clear" or F "branch on accumulator sign bit set" order, in circumstances where the condition is guaranteed to be met. For this specific task, guaranteeing it is trivial: printing characters does not change the contents of the accumulator at all. The solution presented here, however, is more general. We use a T "transfer and clear" order to store the accumulator's contents in storage address θ+17, then jump back to the beginning of the loop and reload the accumulator with an A "add" order. Note that the storage address used as a temporary variable should be set to zero on entry to the loop. <lang edsac>[ Infinite loop

 =============

 A program for the EDSAC

 Works with Initial Orders 2 ]

       T56K
       GK

       O10@  [ letter shift ]

[ 1 ] A17@ [ a += C(17@) ]

       O11@
       O12@
       O13@
       O14@
       O15@
       O16@
       T17@  [ C(17@) = a; a = 0 ]
       E1@   [ if a >= 0 goto 1@ ]

[ 10 ] *F [ 11 ] SF [ 12 ] PF [ 13 ] AF [ 14 ] MF [ 15 ] @F [ carriage return ] [ 16 ] &F [ line feed ]

[ 17 ] PF

       EZPF</lang>

Ela

Direct Approach

<lang ela>open monad io

loop () = do

 putStrLn "SPAM"
 loop ()

loop () ::: IO</lang>

Non-strict version

<lang ela>open monad io

xs = "SPAM"::xs

takeit 0 _ = do return () takeit num (x::xs) = do

 putStrLn x
 takeit (num - 1) xs

_ = takeit 10 xs ::: IO</lang>

Elena

ELENA 4.x: <lang elena>public program() {

   while (true)
   {
       console.writeLine:"spam"
   }

}</lang>

Elixir

<lang elixir>defmodule Loops do

 def infinite do
   IO.puts "SPAM"
   infinite
 end

end

Loops.infinite</lang> or <lang elixir>Stream.cycle(["SPAM"]) |> Enum.each(&IO.puts &1)</lang>

Erlang

<lang erlang> -module (main). -export ([main/0]).

main() ->

 io:fwrite( "SPAM~n" ),
 main().

</lang>

Emacs Lisp

This is run in an external file. <lang elisp>

!/usr/bin/env emacs --script

(while (princ "SPAM\n")) </lang>

ERRE

<lang ERRE> LOOP

 PRINT("SPAM")

END LOOP </lang> You can use also WHILE TRUE..END WHILE or REPEAT...UNTIL FALSE loops.

Euphoria

<lang Euphoria> while 1 do

   puts(1, "SPAM\n")

end while </lang>

F#

<lang fsharp> // Imperative Solution while true do

   printfn "SPAM"

// Functional solution let rec forever () : unit =

   printfn "SPAM"
   forever ()

</lang>

Factor

Tail recursion: <lang factor>: spam ( -- ) "SPAM" print spam ;</lang> Looping combinators: <lang factor>[ "SPAM" print t ] loop</lang> <lang factor>USE: combinators.extras [ "SPAM" print ] forever</lang>

FALSE

Fantom

<lang fantom> class Main {

 public static Void main ()
 {
   while (true) 
   {
     echo ("SPAM")
   }
 }

} </lang>

Fish

<lang fish>a"MAPS"ooooo</lang>

Forth

<lang forth>: email begin ." SPAM" cr again ;</lang>

Fortran

FORTRAN 77 <lang fortran>

  10 WRITE(*,*) 'SPAM'
     GO TO 10
     END

</lang>

Fortran 90 <lang fortran> program spam

 implicit none
 do
   write(*,*) 'SPAM'
 end do

end program spam </lang>

Fortress

<lang fortress> component loops_infinite

 export Executable
 run() = while true do
   println("SPAM")
 end

end </lang>

FreeBASIC

<lang freebasic>' FB 1.05.0

Do

 Print "SPAM"

Loop</lang>

Frink

<lang frink> while true

  println["SPAM"]

</lang>

FutureBasic

Loop de loop -- whose great idea was this? <lang futurebasic> include "ConsoleWindow"

while 1 print "Spam" wend </lang>

Gambas

Click this link to run this code <lang gambas>Public Sub Main()

Do

 Print "SPAM"

Loop

End</lang>

GAP

<lang gap>while true do

   Print("SPAM\n");

od;</lang>

GB BASIC

<lang GB BASIC>10 print "SPAM" 20 goto10</lang>

GML

<lang GML>while(1)

   show_message("SPAM")</lang>

Go

<lang go>package main

import "fmt"

func main() { for { fmt.Printf("SPAM\n") } }</lang>

Groovy

<lang groovy>while (true) {

println 'SPAM'

}</lang>

Halon

<lang halon>forever {

   echo "SPAM";

}</lang> or (due to optimizations, these are equally fast) <lang halon>while (true) {

   echo "SPAM";

}</lang>

Haskell

<lang haskell>forever (putStrLn "SPAM")</lang> or <lang haskell>import Control.Monad.Fix (fix) fix (putStrLn "SPAM" >>) </lang>

Haxe

<lang haxe>while (true)

 Sys.println("SPAM");</lang>

hexiscript

<lang hexiscript>while true; println "SPAM"; endwhile</lang>

HicEst

<lang hicest>DO i = 1, 1E20 ! for i with 16 or more digits: i == i + 1 == loop infinite

   WRITE() "SPAM"

ENDDO</lang>

HolyC

<lang holyc>while(1) Print("SPAM\n");</lang>

Icon and Unicon

There are several ways to write infinite loops in Icon. The most straightforward would be with repeat. <lang icon>procedure main()

  repeat write("SPAM")

end</lang>

Alternately one could use one of these: <lang icon>until &fail do write("SPAM") # always fails, needs succeed to break ... while write("SPAM") # always succeeds, needs failure to break ... every write(|"SPAM") # generator always succeeds, needs failure to break ... while write(|"SPAM") # this is a common mistake that results in an endless loop ... while write(1 to 5) # a clearer version of the same mistake that generates endless 1's</lang>

IDL

<lang IDL>while 1 do print,'SPAM'</lang>

Intercal

Assuming Turing Text I/O with 8-bit ASCII-compatible character set, using COME FROM:

<lang intercal> NOTE THIS IS INTERCAL

      PLEASE ,1 <- #5
      DO ,1 SUB #1 <- #54
      DO ,1 SUB #2 <- #192
      DO ,1 SUB #3 <- #136
      PLEASE ,1 SUB #4 <- #208
      DO ,1 SUB #5 <- #98
      DO COME FROM (1)
      DO READ OUT ,1

(2) DO ,1 SUB #1 <- #134 (1) PLEASE ABSTAIN FROM (2)</lang>

Io

<lang io>loop("SPAM" println)</lang>

J

<lang j>(-[smoutput bind 'SPAM')^:_(1)</lang>

Alternatively,

<lang j>smoutput bind 'SPAM'^:1e99 </lang>

This second implementation relies on numeric inaccuracies in IEEE floating point notation. For example, 1+1e98 is exactly equal to 1e98. That said, 1e98 iterations would still be significantly longer than the practical life of any machine anyone would care to dedicate to this task.

Java

<lang java>while (true) {

  System.out.println("SPAM");

}</lang>

<lang java>for (;;) {

  System.out.println("SPAM");

}</lang>

JavaScript

<lang javascript>for (;;) console.log("SPAM");</lang> <lang javascript>while (true) console.log("SPAM");</lang>

Joy

<lang joy>DEFINE loop == [true []] dip while.

["SPAM\n" putchars] loop.</lang>

jq

<lang jq>recurse("SPAM")</lang>

Output:

"SPAM"
"SPAM"
...

To suppress the quotation marks, invoke jq with the -r option.

Jsish

Julia

<lang Julia> while true

   println("SPAM")

end </lang>

Output:

SPAM
SPAM
SPAM
SPAM
SPAM
SPAM
SPAM

and so on until ^C

K

<lang K> while[1; `0:"SPAM\n"]</lang>

Kotlin

<lang scala>// version 1.0.6

fun main(args: Array<String>) {

   while (true) println("SPAM")

}</lang>

LabVIEW

This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Lang5

Lasso

<lang Lasso>// not wise to run this! while(1 > 0) => {^ 'SPAM\r' ^}</lang>

Liberty BASIC

<CTRL><Break> is used to terminate such loops. <lang lb> while 1

 print "SPAM"

wend end </lang>

Lily

<lang lily> while 1: print("SPAM") </lang>

Lingo

<lang lingo>repeat while TRUE

 put "SPAM"

end repeat</lang>

Lisaac

{ "SPAM\n".print; }.endless_loop;

LiveCode

<lang LiveCode>repeat forever

 put "SPAM" & return

end repeat</lang>

Logo

<lang logo>forever [print "SPAM]</lang>

LOLCODE

<lang lolcode>HAI

 CAN HAS STDIO?
 IM IN YR LOOP 
   VISIBLE "SPAM"
 IM OUTTA YR LOOP

KTHXBYE</lang>

Lua

<lang lua> while true do

 print("SPAM")

end

--Another solution repeat

 print("SPAM")

until false </lang>

M2000 Interpreter

All loops can stop using Esc or Ctrl+C or Break (the last two open dialog box to stop or continue). Using Escape Off we make Esc not work for breaking execution. If Esc works then Ctrl + Y (and other letters except C, A, Z, X, N, M. F, L), open Control form, which we can do: Next Step, Slow Flow, Stop, and we can show code,current stack, variables, or execute immediate statements. This works only in console, not in M2000 forms.

<lang M2000 Interpreter> Module CheckIt {

     Print "SPAM"
     loop

} Checkit </lang> Using a Repeat (or Do) - Always block <lang M2000 Interpreter> Module CheckIt {

     Repeat {
           Print "SPAM"
     } Always

} Checkit </lang>

Printing text rendering using Report. <lang M2000 Interpreter> Module CheckIt {

     \\ stop in every 2/3 of cosole lines
     \\ press spacebar or mouse button to continue
     Report Format$("Spam\n")
     Loop

} Checkit \\ using multiline string, replace report from module above Report {SPAM

</lang>

M4

<lang M4>define(`spam',`SPAM spam') spam</lang>

Make

<lang make>spam:

  @echo SPAM
  $(MAKE)</lang>

Maple

<lang Maple> > do print(SPAM) end; </lang>

Mathematica / Wolfram Language

<lang mathematica>While[True,

Print@"SPAM";
]</lang>

MATLAB / Octave

<lang Matlab>while true

   fprintf('SPAM\n')

end</lang>

Maxima

MAXScript

<lang maxscript>while true do print "SPAM\n"</lang>

Metafont

<lang metafont>forever: message "SPAM"; endfor end</lang>

Microsoft Small Basic

With While. <lang microsoftsmallbasic> While "True"

 TextWindow.WriteLine("SPAM")

EndWhile </lang> With Goto. <lang microsoftsmallbasic> loopStart: TextWindow.WriteLine("SPAM") Goto loopStart </lang>

min

Works with: min version 0.19.3

<lang min>(true) ("SPAM" puts!) while</lang>

МК-61/52

Note: because this device has no text output instead of "SPAM" was used the number (1234).

Modula-2

<lang modula2>LOOP

 InOut.WriteString ("SPAM");
 InOut.WriteLn

END;</lang>

Modula-3

<lang modula3>LOOP

 IO.Put("SPAM\n");

END;</lang>

Monte

<lang Monte> while (true):

   traceln("SPAM")

</lang>

MOO

<lang moo>while (1)

 player:tell("SPAM");

endwhile</lang>

MUMPS

FOR  WRITE "SPAM",!

</lang>

MontiLang

<lang MontiLang>WHILE TRUE

   |SPAM| PRINT .

ENDWHILE</lang> Note that TRUE is simply a variable equal to 1. WHILE 1, any number larger than 0 or any string with a length more than 0 would also work

Nanoquery

<lang Nanoquery>while true

   println "SPAM"

end</lang>

Nemerle

<lang Nemerle>while (true) WriteLine("SPAM");</lang> Or, using recursion: <lang Nemerle>def loop() : void {

   WriteLine("SPAM");
   loop();

}</lang>

NetRexx

<lang NetRexx>/* NetRexx */ options replace format comments java crossref savelog symbols nobinary

 say
 say 'Loops/Infinite'

 loop label spam forever
   say 'SPAM'
   end spam

</lang>

NewLISP

<lang NewLISP>(while (println "SPAM"))</lang>

Nim

<lang nim>while true:

 echo "SPAM"</lang>

NS-HUBASIC

Using FOR: <lang NS-HUBASIC>10 FOR I=0 TO 1 STEP 0 20 PRINT "SPAM" 30 NEXT</lang>

Using GOTO: <lang NS-HUBASIC>10 PRINT "SPAM" 20 GOTO 10</lang>

Using RUN: <lang NS-HUBASIC>10 PRINT "SPAM" 20 RUN</lang>

Oberon-2

<lang oberon2> MODULE InfiniteLoop; IMPORT

 Out;

BEGIN

 LOOP
   Out.String("SPAM");Out.Ln
 END

END InfiniteLoop. </lang>

Objeck

<lang objeck> while(true) {

 "SPAM"->PrintLine();

}; </lang>

OCaml

<lang ocaml>while true do

 print_endline "SPAM"

done</lang>

or

<lang ocaml>let rec inf_loop() =

 print_endline "SPAM";
 inf_loop()

in inf_loop()</lang>

Seen like this it looks like the "too much functional" danger when a "while" loop looks far simpler, but the functional loop may be useful to provide data to the next loop without using mutable variable.

Occam

<lang occam>#USE "course.lib" PROC main (CHAN BYTE screen!)

 WHILE TRUE
   out.string("SPAM*c*n", 0, screen)

</lang>

Octave

<lang octave>while(1)

 disp("SPAM")

endwhile</lang>

Oforth

<lang Oforth>begin "SPAM" . again</lang>

Ol

<lang scheme> (let loop ()

  (display "SPAM")
  (loop))

</lang>

OPL

<lang opl>PROC main:

 LOCAL loop%
 loop%=1
 while loop%=1
 PRINT "SPAM"
 ENDWH

ENDP</lang>

Oz

<lang oz>for do

  {Show 'SPAM'}

end</lang>

PARI/GP

<lang parigp>while(1,

 print("SPAM")

);</lang>

For a shorter version, note that print returns gnil which is evaluated as false. A 'cheating' solution might use print(SPAM) on the hope that the variable SPAM is uninitialized and hence prints as the monomial in itself. But with the ' operator that evaluation can be forced, regardless of the current value (if any) of that variable: <lang parigp>until(print('SPAM),)</lang>

Pascal

<lang pascal>while true do

 writeln('SPAM');</lang>

Alternatively: <lang pascal>repeat

 writeln('SPAM')

until false;</lang>

Perl

<lang perl>while(1){

   print "SPAM\n";

}</lang>

or equivalently

<lang perl>print "SPAM\n" while 1;</lang>

Perl 6

Works with: Rakudo Star version 2010.08

<lang perl6>loop {

   say 'SPAM';

}</lang> In addition, there are various ways of writing lazy, infinite lists in Perl 6: <lang perl6>print "SPAM\n" xx *; # repetition operator print "SPAM\n", ~* ... *; # sequence operator map {say "SPAM"}, ^Inf; # upto operator</lang>

Phix

<lang Phix>while 1 do

   puts(1,"SPAM\n")

end while</lang>

PHP

<lang php>while(1)

   echo "SPAM\n";</lang>

PicoLisp

<lang PicoLisp>(loop (prinl "SPAM"))</lang>

Pike

<lang pike> while(1)

   write("SPAM\n");

</lang>

PILOT

<lang pilot>*TypeSpam type:SPAM jump:*TypeSpam</lang>

PL/I

<lang PL/I> do forever;

  put list ('SPAM'); put skip;

end; </lang>

Plain $T e X$

Compile in console mode, with, e.g. "pdftex <file name>". <lang tex>\newlinechar`\^^J \def\spam{\message{SPAM^^J}\spam}% \spam</lang>

Pop11

<lang pop11>while true do

   printf('SPAM', '%p\n');

endwhile;</lang>

PostScript

simple infinite loop: <lang postscript>{}loop</lang>

A bit more complex infinite loop: <lang postscript>/go {

 /spam 
    { (SPAM\n) print flush } 
 bind def % bind and define spam

 { spam } % procedure that will be executed by loop and will call spam to print
 loop % the loop

}

%start spamming! go</lang>

PowerShell

<lang powershell>for () {

   "SPAM"

}</lang>

Prolog

<lang prolog>repeat, write('SPAM'), nl, fail.</lang>

Pure Data

Screenshot: https://i.imgur.com/IrwaafZ.png

<lang Pure Data>#N canvas 426 88 450 300 10;

X obj 17 75 print;
X msg 17 55 SPAM;
X obj 17 35 metro 1;
X msg 17 15 1;
X connect 1 0 0 0;
X connect 2 0 1 0;
X connect 3 0 2 0;</lang>

Notes: the loop is started by clicking the |1(, a [loadbang] could additionally be used. An [until] object, sent a bang, will loop forever, but will hang Pure Data, whereas a high-speed metro will function perfectly.

PureBasic

Repeat/Forever

<lang PureBasic>Repeat

 PrintN("SPAM")

ForEver</lang>

Goto

<lang PureBasic>PrintIt: PrintN("SPAM") Goto PrintIt</lang>

Python

In Python 2: <lang python>while 1:

  print "SPAM"</lang>

In python 3: <lang python>while 1:

  print("SPAM")</lang>

Note: one can also use: "True" or any other non-false value. In Python the following values are false: 0, "" (empty string), (,) and {} and [] (empty tuples, dictionaries or lists), None (the special object), and the False object. Any non-empty collection or string or non-zero numeric value is considered "True". However, according to Python Wiki, for Python versions 2.3+ this variant is optimized by the interpreter and thus is the fastest.

R

Note that the default R Gui buffers outputs before pushing them to the screen. To see this run either run in terminal mode, right click on the GUI window and deselect "Buffered Output" prior to execution, or add a call to flush.console() in the loop.

<lang R>repeat print("SPAM")</lang>

Racket

lang racket

Using recursion

(define (loop)

 (displayln "SPAM")
 (loop))

(loop)

Using a for loop

(for ([i (in-naturals)])

 (displayln "SPAM"))

</lang>

REBOL

<lang REBOL>forever [print "SPAM"]</lang>

Red

<lang Red>forever [ print "SPAM" ]</lang>

Retro

<lang Retro>[ "SPAM\n" puts -1 ] while</lang>

REXX

simple

<lang rexx>/*REXX program displays the word SPAM forever. */

 do forever
 say 'SPAM'
 end   /*DO forever*/
                                      /*control will never reach here. */
                                      /*don't stick a fork in it.      */</lang>

esoteric

<lang rexx>/*REXX program displays the word SPAM forever. */

  do  while  1==1                      /*esoteric  "forever"  clause.   */
  say 'SPAM'
  end   /*DO while 1==1*/
                                       /*control will never reach here. */
                                       /*don't stick a fork in it.      */</lang>

GO TO version

<lang rexx>/*REXX program displays the word SPAM forever. */

tell_it: say 'SPAM' signal tell_it /*REXX's version of a GO TO */

                                      /*control will never reach here. */
                                      /*don't stick a fork in it.      */</lang>

too clever by half

<lang rexx>/*REXX program displays the word SPAM forever. */

 do  until  0>1                       /*too-clever-by-half forever loop*/
 say 'SPAM'
 end   /*DO until 0>1*/
                                      /*control will never reach here. */
                                      /*don't stick a fork in it.      */</lang>

Ring

<lang ring> while true

     see "Spam"

end </lang>

Robotic

This will display the word SPAM at the bottom of the screen indefinitely: <lang robotic>

"infinite_loop"

"SPAM"

goto "infinite_loop" </lang>

Ruby

Rust

<lang rust>fn main() {

   loop {
       println!("SPAM");
   }

}</lang>

Run BASIC

<lang runbasic>[loop] print "Spam" :goto [loop]

while 1 print "Spam" wend</lang>

S-lang

<lang S-lang>forever print("SPAM");</lang>

Salmon

<lang Salmon>while (true)

   "SPAM"!;</lang>

Sather

<lang sather>class MAIN is

 main is
   loop 
     #OUT + "Spam\n"; 
   end;
 end;

end;</lang>

Scala

<lang scala>while (true)

 println("SPAM")</lang>

Scheme

<lang scheme>((lambda (x) (display "SPAM") (newline) (x x))

(lambda (x) (display "SPAM") (newline) (x x)))

</lang>

or, less Schemishly but with less redundancy:

<lang scheme>(do () (#f) (display "SPAM") (newline))</lang>

Scilab

Works with: Scilab version 5.5.1

<lang>while %T

   printf("SPAM\n")

end</lang>

Output:

SPAM
SPAM
SPAM
SPAM
...

sed

<lang sed>:loop s/.*/SPAM/ p t loop</lang> Sed requires at least one line of input to execute, so run as follows:

echo | sed ':loop;s/.*/SPAM/;p;t loop'

Seed7

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

const proc: main is func

 begin
   while TRUE do
     writeln("SPAM");
   end while;
 end func;</lang>

Self

<lang self>['SPAM' printLine] loop</lang>

Sidef

Slate

<lang slate>[inform: 'SPAM'] loop</lang>

Smalltalk

<lang smalltalk>[ true ] whileTrue: [ 'SPAM' displayNl ]</lang>

SNOBOL4

<lang snobol>loop output = "SPAM" :(loop) end</lang>

SNUSP

<lang snusp>@\>@\>@\>@\>++++++++++===!/ < < < < \

|  |  |  \M=@@@@+@+++++# \.>.>.>.>./
|  |  \A=@@+@@@@+++#
|  \P=@@+@@+@@+++#
\S=@@+@+@@@+++#</lang>

Sparkling

<lang sparkling>while true {

   print("SPAM");

}</lang>

or

<lang sparkling>do {

   print("SPAM");

} while true;</lang>

or

<lang sparkling>for var b = true; b; b = true {

   printf("SPAM\n");

}</lang>

etc.

Spin

Works with: BST/BSTC

Works with: FastSpin/FlexSpin

Works with: HomeSpun

Works with: OpenSpin

<lang spin>con

 _clkmode = xtal1 + pll16x
 _clkfreq = 80_000_000

obj

 ser : "FullDuplexSerial.spin"

pub main

 ser.start(31, 30, 0, 115200)

 repeat
   ser.str(string("SPAM",13,10))

 waitcnt(_clkfreq + cnt)
 ser.stop
 cogstop(0)</lang>

SPL

 #.output("SPAM")

<</lang>

Standard ML

<lang sml>while true do

 print "SPAM\n";</lang>

or

<lang sml>let

 fun inf_loop () = (
   print "SPAM\n";
   inf_loop ()
 )

in

 inf_loop ()

end</lang>

Seen like this it looks like the "too much functional" danger when a "while" loop looks far simpler, but the functional loop may be useful to provide data to the next loop without using mutable variable.

Stata

<lang stata>while 1 {

       display "SPAM"

}</lang>

Mata

<lang stata>while (1) printf("SPAM\n")</lang>

Also possible with a for loop, but unlike C, the middle expression is not optional:

<lang stata>for (;1;) printf("SPAM\n")</lang>

SQL PL

Works with: Db2 LUW

version 9.7 or higher.

With SQL PL: <lang sql pl> --#SET TERMINATOR @

SET SERVEROUTPUT ON@

BEGIN

DECLARE I SMALLINT DEFAULT 1;
WHILE (I = I) DO
 CALL DBMS_OUTPUT.PUT_LINE('SPAM');
END WHILE;

END @ </lang> Output:

db2 -td@
db2 => SET SERVEROUTPUT ON@

db2 => BEGIN
...
db2 (cont.) => END @
DB21034E  The command was processed as an SQL statement because it was not a
valid Command Line Processor command.  During SQL processing it returned:
SQL20511N  There is not enough available space in the "DBMS_OUTPUT" message
buffer.  SQLSTATE=54035

SPAM
SPAM
SPAM
SPAM
...

Swift

<lang swift>while true {

   println("SPAM")

}</lang>

SystemVerilog

<lang SystemVerilog>program main;

 initial forever $display("SPAM");

endprogram </lang>

Transact-SQL

<lang sql>WHILE 1=1 BEGIN

PRINT "SPAM"

END</lang>

Tcl

<lang tcl>while true {

   puts SPAM

}

or

for {} 1 {} {

   puts SPAM

}</lang>

TI-83 BASIC

There are a few ways to achieve this in TI-83 BASIC

 :Lbl 1
 :Disp "SPAM
 :Goto 1

</lang>

Another way is by using a While loop

 :While 1
 :Disp "SPAM
 :End

</lang>

TI-89 BASIC

<lang ti89b>Loop

 Disp "SPAM"

EndLoop</lang>

TorqueScript

<lang Torque>While(1)

   echo("SPAM");</lang>

Trith

<lang trith>["SPAM" print] loop</lang>

TUSCRIPT

TUSCRIPT has no infinite loop. 999999999 loops are the limit. <lang tuscript> $$ MODE TUSCRIPT LOOP/999999999 print "spam" ENDLOOP </lang>

UNIX Shell

Works with: Bourne Shell

Use any of these loops: <lang bash>while :; do echo SPAM; done</lang>

<lang bash>while true; do echo "SPAM"; done</lang>

<lang bash>until false; do echo "SPAM"; done</lang>

Works with: bash

Works with: ksh93

Works with: zsh

C Shell

<lang bash>while (1) echo SPAM end</lang>

es

<lang es>forever {echo SPAM}</lang>

UnixPipes

Unlambda

Ursa

Translation of: Python

<lang ursa>while true out "SPAM" endl console end while</lang>

V

<lang v>true [

  'SPAM' puts

] while</lang>

Vala

<lang vala>for(;;) stdout.printf("SPAM\n");</lang> <lang vala>while(true) stdout.printf("SPAM\n");</lang> <lang vala>do stdout.printf("SPAM\n"); while(true);</lang>

VAX Assembly

<lang VAX Assembly> 0000 0000 1 .entry main,0

                  4D415053 8F   DD  0002     2 	pushl	#^a"SPAM"		;string on stack
                           5E   DD  0008     3 	pushl	sp			;reference to string
                           04   DD  000A     4 	pushl	#4			;+length = descriptor
                                    000C     5 loop:
                           5E   DD  000C     6 	pushl	sp			;descriptor by reference
             00000000'GF   01   FB  000E     7 	calls	#1, g^lib$put_output	;show message
                           F5   11  0015     8 	brb	loop			;forever
                                    0017     9 
                                    0017    10 .end	main</lang>

Vedit macro language

<lang vedit>while (1) {

   Message("Spam\n")

}</lang> or: <lang vedit>do {

   Message("Spam\n")

} while (1)</lang> or: <lang vedit>for (;1;) {

   Message("Spam\n")

}</lang> "Nearly infinite" loop can be done by using constant ALL (=1073741824) as repeat count: <lang vedit>Repeat (ALL) {

   Message("Spam\n")

}</lang>

Visual Basic

<lang vb>Do

   Debug.Print("SPAM")

Loop</lang>

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

<lang vbnet>Do

   Console.WriteLine("SPAM")

Loop</lang>

Wart

<lang wart>repeat :forever

 prn "spam"</lang>

Wee Basic

<lang Wee Basic>let loop=1 while loop=1 print 1 "SPAM" wend end</lang>

X86 Assembly

Works with: NASM version Linux

<lang asm> section .text global _start

_start: mov edx, len mov ecx, msg mov ebx, 1 mov eax, 4 int 0x80 jmp _start

section .data msg db "SPAM",0xa len equ $-msg </lang>

XLISP

It is of course possible to use a WHILE loop with a condition that will always evaluate to true: <lang lisp>(defun keep-printing-spam ()

   (while t
       (display "SPAM")
       (newline) ) )</lang>

Although this idiom is very common (in many programming languages), however, it feels a bit like a misuse of a looping construct that is meant to be conditional. If an unconditional jump is really what we want, then that is what we have goto for; or rather, in XLISP we do not have goto (in so many words) but we can achieve the effect of it using tail recursion. <lang lisp>(defun keep-printing-spam ()

   (display "SPAM")
   (newline)
   (keep-printing-spam) )</lang>

XPL0

Z80 Assembly

Using the Amstrad CPC firmware:

<lang z80>org $4000

txt_output: equ $bb5a

start: ld hl,spam

print: ld a,(hl) cp 0 jr z,start call txt_output inc hl jr print

spam: defm "SPAM\r\n\0"</lang>

zkl

<lang zkl>while(1) { println("SPAM") } while(True){ println("SPAM") } foreach _ in ([0..]){ println("SPAM") } [0..].pump(Console.println,T(Void,"SPAM")); [0..].pump(fcn{ println("SPAM") }); fcn{ println("SPAM"); return(self.fcn()) }(); // tail recursive lambda</lang>

@@ Line 1,262: / Line 1,262: @@
 =={{header|Pike}}==
-<lang pike>int main(){
+<lang pike>
-   while(1) write("SPAM\n");
+while(1)
+    write("SPAM\n");
-}</lang>
+</lang>
 =={{header|PILOT}}==