Loops/Infinite: Difference between revisions

;Task:

Print out &nbsp; &nbsp; &nbsp; <big> '''SPAM''' </big> &nbsp; &nbsp; &nbsp; followed by a &nbsp; ''newline'' &nbsp; in an infinite loop.

<br><br>

 

=={{header|360 Assembly}}==

This for sure will result in a severe WTO buffer shortage.

INFINITE CSECT , this PGM control section

INFINITE AMODE 31 addressing mode 31 bit

RETURN PR , return to caller

END INFINITE

 

=={{header|4DOS Batch}}==

 

do forever

echo SPAM

 

=={{header|6502 Assembly}}==

Specific OS/hardware routines for printing are left unimplemented.

PrintLoop: LDA MSG,x

JSR PrintAccumulator ;routine not implemented

BEQ InfiniteLoop

 

 

=={{header|6800 Assembly}}==

.tf spam6800.obj,AP1

.lf spam6800

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

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

 

=={{header|8th}}==

One way:

: inf "SPAM\n" . recurse ;

Another way:

: inf repeat "SPAM\n" . again ;

=={{header|ACL2}}==

(declare (xargs :mode :program))

(if nil

nil

(prog2$ (cw "SPAM~%")

 

=={{header|ActionScript}}==

trace("SPAM");

 

=={{header|Ada}}==

Put_Line("SPAM");

 

=={{header|Agena}}==

Tested with Agena 2.9.5 Win32

print( "SPAM" )

 

=={{header|Aime}}==

o_text("SPAM\n");

 

=={{header|ALGOL 68}}==

printf($"SPAM"l$)

Or the classic "dynamic halt":

printf($"SPAM"l$);

 

=={{header|ALGOL W}}==

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

 

=={{header|AmigaE}}==

LOOP

WriteF('SPAM')

ENDLOOP

=={{header|AppleScript}}==

log "SPAM"

 

=={{header|ARM Assembly}}==

.global main

 

message:

.asciz "SPAM\n"

 

=={{header|AutoHotkey}}==

 

=={{header|AWK}}==

while(1) {

print "SPAM"

}

 

=={{header|Axe}}==

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

 

Disp "SPAM",i

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

Old-fashioned syntax:

print "SPAM"

 

Standard BASIC:

print "SPAM"

 

Also

print "SPAM"

 

{{works with|Applesoft BASIC}}

{{works with|Commodore BASIC}}

{{works with|ZX Spectrum Basic}}

 

==={{header|Applesoft BASIC}}===

 

=={{header|Batch File}}==

Using <code>goto</code>:

:loop

echo SPAM

Another variant which uses Windows NT's <code>for</code> statement:

 

{{works with|Windows NT|4 or later}}

This essentially is a counted loop which starts at <code>1</code>, increments by <code>0</code> and stops when the counter reaches <code>2</code>.

 

=={{header|BBC BASIC}}==

PRINT "SPAM"

 

=={{header|bc}}==

 

=={{header|beeswax}}==

 

=={{header|Befunge}}==

Because the 2-D code space is toroidal, all loops are infinite

unless explicitly stopped with '''@'''.

 

 

=={{header|Bracmat}}==

 

=={{header|Brat}}==

 

=={{header|C}}==

or

or

or

or

spam: puts("SPAM");

goto spam;

 

 

=={{header|C++}}==

{{trans|C}}

or

or

 

{

 

=={{header|Chapel}}==

 

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

PROGRAM-ID. Spam.

 

 

GOBACK

[[OpenCOBOL]] supports a <code>FOREVER</code> clause for <code>PERFORM</code> which will have the same effect.

 

=={{header|CoffeeScript}}==

console.log 'SPAM'

 

 

=={{header|Comal}}==

PRINT "SPAM"

 

=={{header|Common Lisp}}==

 

=={{header|D}}==

Some common ways to create an infinite printing loop:

 

void main() {

while (true)

writeln("SPAM");

 

 

void main() {

writeln("SPAM");

while (true);

 

 

void main() {

for ( ; ; )

writeln("SPAM");

 

 

void main() {

writeln("SPAM");

goto LOOP;

 

=={{header|Dart}}==

main() {

while(true) {

}

}

 

=={{header|dc}}==

 

This loop is a tail-recursive function.

the outer ''dx'' makes the first call,

and the inner ''dx'' makes each recursive call.

=={{header|DCL}}==

$ write sys$output "SPAM"

 

=={{header|Delphi}}==

 

 

=={{header|DWScript}}==

 

 

=={{header|E}}==

 

println("SPAM")

 

println("SPAM")

f <- ()

}

 

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.

 

=={{header|EDSAC order code}}==

The EDSAC instruction set does not include an unconditional jump: it is necessary to synthesize it by using either an <code>E</code> "branch on accumulator sign bit clear" or <code>F</code> "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 <code>T</code> "transfer and clear" order to store the accumulator's contents in storage address <i>θ</i>+17, then jump back to the beginning of the loop and reload the accumulator with an <code>A</code> "add" order. Note that the storage address used as a temporary variable should be set to zero on entry to the loop.

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

 

[ 17 ] PF

 

 

=={{header|Ela}}==

===Direct Approach===

 

 

loop () = do

loop ()

 

 

===Non-strict version===

 

 

xs = "SPAM"::xs

takeit (num - 1) xs

 

 

=={{header|Elena}}==

while (true)

 

=={{header|Elixir}}==

def infinite do

IO.puts "SPAM"

end

 

or

 

=={{header|Erlang}}==

-module (main).

-export ([main/0]).

io:fwrite( "SPAM~n" ),

main().

 

=={{header|ERRE}}==

LOOP

PRINT("SPAM")

END LOOP

You can use also WHILE TRUE..END WHILE or REPEAT...UNTIL FALSE loops.

 

=={{header|Euphoria}}==

while 1 do

puts(1, "SPAM\n")

end while

 

=={{header|F Sharp|F#}}==

// Imperative Solution

while true do

printfn "SPAM"

forever ()

 

=={{header|Factor}}==

 

=={{header|FALSE}}==

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Forth}}==

 

=={{header|Fortran}}==

FORTRAN 77

10 WRITE(*,*) 'SPAM'

GO TO 10

END

 

Fortran 90

program spam

implicit none

end do

end program spam

 

=={{header|FreeBASIC}}==

 

Do

Print "SPAM"

 

=={{header|Frink}}==

while true

println["SPAM"]

 

=={{header|FutureBasic}}==

Loop de loop -- whose great idea was this?

 

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=e63dcdc939f8a7dcfd3194d884f8d4a5 Click this link to run this code]'''

 

Do

Loop

 

 

=={{header|GAP}}==

Print("SPAM\n");

 

=={{header|GML}}==

 

=={{header|Go}}==

import "fmt"

func main() {

for {

fmt.Printf("SPAM\n")

}

 

=={{header|Groovy}}==

println 'SPAM'

 

=={{header|Halon}}==

echo "SPAM";

or (due to optimizations, these are equally fast)

echo "SPAM";

 

=={{header|Haskell}}==

or

 

=={{header|HicEst}}==

WRITE() "SPAM"

 

=={{header|HolyC}}==

 

=={{header|Icon}} and {{header|Unicon}}==

There are several ways to write infinite loops in Icon. The most straightforward would be with repeat.

repeat write("SPAM")

 

Alternately one could use one of these:

...

while write("SPAM") # always succeeds, needs failure to break

while write(|"SPAM") # this is a common mistake that results in an endless loop

...

 

=={{header|IDL}}==

 

=={{header|Intercal}}==

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

 

PLEASE ,1 <- #5

DO ,1 SUB #1 <- #54

DO READ OUT ,1

(2) DO ,1 SUB #1 <- #134

 

=={{header|Io}}==

 

=={{header|J}}==

 

 

Alternatively,

 

 

This second implementation relies on numeric inaccuracies in IEEE floating point notation.

 

=={{header|Java}}==

 

 

=={{header|JavaScript}}==

 

=={{header|Joy}}==

 

=={{header|jq}}==

{{Out}}

"SPAM"

 

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

 

=={{header|Julia}}==

while true

println("SPAM")

end

{{out}}

<pre>

 

=={{header|K}}==

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

while (true) println("SPAM")

 

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Loops_Infinite.png}}

 

=={{header|Lang5}}==

 

=={{header|Lasso}}==

while(1 > 0) => {^

'SPAM\r'

 

=={{header|Liberty BASIC}}==

<CTRL><Break> is used to terminate such loops.

while 1

print "SPAM"

wend

end

 

=={{header|Lily}}==

while 1: print("SPAM")

 

=={{header|Lingo}}==

put "SPAM"

 

=={{header|Lisaac}}==

 

=={{header|LiveCode}}==

put "SPAM" & return

 

=={{header|Logo}}==

 

=={{header|LOLCODE}}==

CAN HAS STDIO?

IM IN YR LOOP

VISIBLE "SPAM"

IM OUTTA YR LOOP

 

=={{header|Lua}}==

while true do

print("SPAM")

print("SPAM")

until false

 

=={{header|M4}}==

spam')

 

=={{header|Make}}==

@echo SPAM

 

=={{header|Maple}}==

> do print(SPAM) end;

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Print@"SPAM";

 

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

fprintf('SPAM\n')

 

=={{header|Maxima}}==

=={{header|MAXScript}}==

 

=={{header|Metafont}}==

 

 

=={{header|МК-61/52}}==

 

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

 

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

InOut.WriteString ("SPAM");

InOut.WriteLn

 

=={{header|Modula-3}}==

IO.Put("SPAM\n");

 

=={{header|Monte}}==

 

while (true):

traceln("SPAM")

 

=={{header|MOO}}==

player:tell("SPAM");

=={{header|MUMPS}}==

FOR WRITE "SPAM",!

 

=={{header|Nemerle}}==

Or, using recursion:

{

WriteLine("SPAM");

loop();

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

say 'SPAM'

end spam

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

 

=={{header|Oberon-2}}==

MODULE InfiniteLoop;

IMPORT

END

END InfiniteLoop.

 

=={{header|Objeck}}==

while(true) {

"SPAM"->PrintLine();

};

 

=={{header|OCaml}}==

print_endline "SPAM"

 

or

 

print_endline "SPAM";

inf_loop()

in

 

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.

 

=={{header|Occam}}==

PROC main (CHAN BYTE screen!)

WHILE TRUE

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

 

=={{header|Octave}}==

disp("SPAM")

 

=={{header|Oforth}}==

 

 

=={{header|Oz}}==

{Show 'SPAM'}

 

=={{header|PARI/GP}}==

print("SPAM")

 

For a shorter version, note that <code>print</code> returns <code>gnil</code> which is evaluated as <code>false</code>.

A 'cheating' solution might use <code>print(SPAM)</code> on the hope that the variable SPAM is uninitialized and hence prints as the monomial in itself.

But with the <code>'</code> operator that evaluation can be forced, regardless of the current value (if any) of that variable:

 

=={{header|Pascal}}==

Alternatively:

writeln('SPAM')

 

=={{header|Perl}}==

 

 

 

=={{header|Phix}}==

 

=={{header|PHP}}==

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

 

=={{header|PILOT}}==

type:SPAM

 

=={{header|PL/I}}==

do forever;

put list ('SPAM'); put skip;

 

=={{header|plainTeX}}==

Compile in console mode, with, e.g. "pdftex <file name>".

\def\spam{\message{SPAM^^J}\spam}%

 

=={{header|Pop11}}==

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

 

=={{header|PostScript}}==

simple infinite loop:

 

A bit more complex infinite loop:

/spam

{ (SPAM\n) print flush }

 

%start spamming!

 

=={{header|PowerShell}}==

"SPAM"

 

=={{header|Prolog}}==

 

=={{header|Pure Data}}==

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

 

#X obj 17 75 print;

#X msg 17 55 SPAM;

#X connect 1 0 0 0;

#X connect 2 0 1 0;

 

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.

=={{header|PureBasic}}==

===Repeat/Forever===

PrintN("SPAM")

 

===Goto===

PrintN("SPAM")

 

=={{header|Python}}==

 

Note: one can also use: "True" or any other non-false value.

Any non-empty collection or string or non-zero numeric value is considered "True".

However, according to [http://wiki.python.org/moin/PythonSpeed#Takeadvantageofinterpreteroptimizations Python Wiki], for Python versions 2.3+ this variant is optimized by the interpreter and thus is the fastest.

 

=={{header|R}}==

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.

 

 

=={{header|Racket}}==

 

#lang racket

 

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

(displayln "SPAM"))

 

=={{header|REBOL}}==

 

=={{header|Red}}==

print "SPAM"

 

=={{header|Retro}}==

 

=={{header|REXX}}==

===simple===

 

do forever

end /*DO forever*/

/*control will never reach here. */

 

===esoteric===

 

do while 1==1 /*esoteric "forever" clause. */

end /*DO while 1==1*/

/*control will never reach here. */

 

===GO TO version===

 

tell_it: say 'SPAM'

 

/*control will never reach here. */

===too clever by half===

 

do until 0>1 /*too-clever-by-half forever loop*/

end /*DO until 0>1*/

/*control will never reach here. */

 

=={{header|Ring}}==

while true

see "Spam"

end

 

 

 

=={{header|Run BASIC}}==

 

while 1

print "Spam"

 

 

=={{header|S-lang}}==

 

=={{header|Salmon}}==

 

=={{header|Sather}}==

main is

loop

end;

end;

 

=={{header|Scala}}==

 

=={{header|Scheme}}==

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

 

or, less Schemishly but with less redundancy:

 

 

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

printf("SPAM\n")

{{out}}

<pre>SPAM

 

=={{header|sed}}==

s/.*/SPAM/

p

Sed requires at least one line of input to execute, so run as follows:

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

 

=={{header|Seed7}}==

 

const proc: main is func

writeln("SPAM");

end while;

 

=={{header|Self}}==

 

=={{header|Sidef}}==

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

=={{header|SNOBOL4}}==

 

=={{header|SNUSP}}==

| | | \M=@@@@+@+++++# \.>.>.>.>./

| | \A=@@+@@@@+++#

| \P=@@+@@+@@+++#

 

=={{header|Sparkling}}==

print("SPAM");

 

or

 

print("SPAM");

 

or

 

printf("SPAM\n");

 

etc.

 

=={{header|SPL}}==

#.output("SPAM")

 

=={{header|Standard ML}}==

 

or

 

fun inf_loop () = (

print "SPAM\n";

in

inf_loop ()

 

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.

=={{header|Stata}}==

 

display "SPAM"

 

=== Mata ===

 

Also possible with a '''[https://www.stata.com/help.cgi?m2_for for]''' loop, but unlike C, the middle expression is not optional:

 

 

=={{header|Swift}}==

println("SPAM")

 

=={{header|SystemVerilog}}==

 

initial forever $display("SPAM");

endprogram

 

=={{header|Tcl}}==

puts SPAM

}

for {} 1 {} {

puts SPAM

 

=={{header|TI-83 BASIC}}==

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

 

:Lbl 1

:Disp "SPAM

:Goto 1

 

Another way is by using a While loop

 

:While 1

:Disp "SPAM

:End

 

=={{header|TI-89 BASIC}}==

 

Disp "SPAM"

 

=={{header|TorqueScript}}==

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

TUSCRIPT has no infinite loop. 999999999 loops are the limit.

$$ MODE TUSCRIPT

LOOP/999999999

print "spam"

ENDLOOP

 

=={{header|UNIX Shell}}==

 

Use any of these loops:

 

 

 

{{works with|bash}}

{{works with|zsh}}

 

 

==={{header|C Shell}}===

echo SPAM

 

==={{header|es}}===

 

=={{header|UnixPipes}}==

 

=={{header|Unlambda}}==

 

=={{header|Ursa}}==

{{trans|Python}}

out "SPAM" endl console

 

=={{header|V}}==

'SPAM' puts

 

=={{header|Vala}}==

=={{header|Vedit macro language}}==

Message("Spam\n")

or:

Message("Spam\n")

or:

Message("Spam\n")

"Nearly infinite" loop can be done by using constant ALL (=1073741824) as repeat count:

Message("Spam\n")

 

=={{header|Visual Basic}}==

Debug.Print("SPAM")

 

=={{header|Visual Basic .NET}}==

'''Platform:''' [[.NET]]

{{works with|Visual Basic .NET|9.0+}}

Console.WriteLine("SPAM")

 

=={{header|Wart}}==

 

=={{header|X86 Assembly}}==

{{works with|NASM|Linux}}

section .text

global _start

msg db "SPAM",0xa

len equ $-msg

 

=={{header|XLISP}}==

It is of course possible to use a <code>WHILE</code> loop with a condition that will always evaluate to true:

(while t

(display "SPAM")

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 <tt>goto</tt> for; or rather, in XLISP we do not have <tt>goto</tt> (in so many words) but we can achieve the effect of it using tail recursion.

(display "SPAM")

(newline)

 

=={{header|XPL0}}==

loop Text(0, "SPAM

 

=={{header|Z80 Assembly}}==

Using the Amstrad CPC firmware:

 

 

txt_output: equ $bb5a

jr print

 

 

=={{header|zkl}}==

while(True){ println("SPAM") }

foreach _ in ([0..]){ println("SPAM") }

[0..].pump(Console.println,T(Void,"SPAM"));

[0..].pump(fcn{ println("SPAM") });

 

{{omit from|GUISS}}