Loops/Infinite

Specifically print out "SPAM" followed by a newline in an infinite loop.

ALGOL 68

DO
  printf($"SPAM"l$)
OD

Or the classic "dynamic halt":

loop x:
   printf($"SPAM"l$);
loop x

AutoHotkey

<lang autohotkey>Loop

 MsgBox SPAM `n</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>

With classic (minimal) BASIC, the standard way to make an infinite loop would be:

10 PRINT "SPAM"
20 GOTO 10

Befunge

Because the 2-D code space is toroidal, all loops are infinite unless explicitly stopped with @.

55+"MAPS",,,,,

Brainf***

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

C

<lang c>while(1) puts("SPAM\n");</lang> or <lang c> for(;;) puts("SPAM\n");</lang> or <lang c>do { puts("SPAM\n"); } while(1);</lang>

ColdFusion

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

With tags:

<cfloop condition = "true NEQ false">
  SPAM
</cfloop>

With script:

<cfscript>
  while( true != false )
  {
    writeOutput( "SPAM" );
  }
</cfscript>

Common Lisp

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

D

<lang d>while(true) writefln("SPAM") ;</lang> <lang d>for(;;) writefln("SPAM") ;</lang> <lang d>l: writefln("SPAM"); goto l;</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.

Erlang

-module (main).
-export ([main/1]).

main(Any) ->
  io:fwrite("SPAM~n",[]),
  main(Any)

FALSE

[1]["SPAM
"]#

Forth

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

Fortran

Works with: Fortran version 90 and later

<lang fortran>DO

 WRITE(*,*) "SPAM"

END DO</lang> Although deprecated GOTO is still available <lang fortran>10 WRITE(*,*) "SPAM"

  GOTO 10</lang>

Haskell

<lang haskell>forever (putStrLn "SPAM")</lang>

JavaScript

<lang javascript>for (;;) print("SPAM"); while (true) print("SPAM");</lang>

Make

<lang make>spam:

  @echo SPAM
  $(MAKE)</lang>

MAXScript

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

Metafont

<lang metafont>forever: message "SPAM"; endfor 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.

Octave

<lang octave>while(1)

 disp("SPAM")

endwhile</lang>

Pascal

<lang pascal>while true do

 writeln('SPAM');</lang>

Alternatively: <lang pascal>repeat

 writeln('SPAM')

until false;</lang>

Perl

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

PHP

<lang php>while(1)

   echo "SPAM\n";</lang>

Pop11

while true do
    printf('SPAM', '%p\n');
endwhile;

Prolog

repeat, write('SPAM'), nl, fail.

Python

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

R

Note that the default R Gui buffers outputs before pushing them to the screen. To see this run either run in terminal mode or right click on the GUI window and deselect "Buffered Output" prior to execution.

<lang R> while (TRUE) {print("SPAM")} </lang>

Ruby

<lang ruby>loop do

  puts "SPAM"

end</lang>

Scheme

<lang scheme>(do ()

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

Slate

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

Smalltalk

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

SNUSP

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

Standard ML

<lang ocaml>while true do

 print "SPAM\n";</lang>

or

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

Transact-SQL

<lang tsql>WHILE 1=1 BEGIN

PRINT "SPAM"

END</lang>

Tcl

<lang tcl>while true {

   puts SPAM

}

or

for {} 1 {} {

   puts SPAM

}</lang>

  'SPAM' puts

] while</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

This example is incorrect. Please fix the code and remove this message.

Details: This example is written in VB.Net, and will not work as-is under non-.Net VB.

<lang vb>Do

   Console.WriteLine("SPAM")

Loop</lang>

Visual Basic .NET

Platform: .NET

Works with: Visual Basic .NET version 9.0+

<lang vbnet>Do

   Console.WriteLine("SPAM")

Loop</lang>