Repeat: Difference between revisions

 

;Task:

The latter procedure is executed a number of times equal to the accepted integer.

<br><br>

 

=={{header|Ada}}==

 

 

procedure Repeat_Example is

begin

Repeat(Hello'Access, 3); -- Hello'Access points to the procedure Hello

 

Output:

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

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

# operator that executes a procedure the specified number of times #

OP REPEAT = ( INT count, PROC VOID routine )VOID:

 

)

Output:

<pre>

+3 +9

</pre>

 

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

 

=={{header|Arturo}}==

 

 

 

 

{{out}}

 

 

=={{header|AutoHotkey}}==

return

 

fMsgBox(){

MsgBox hello

 

=={{header|AWK}}==

# syntax: GAWK -f REPEAT.AWK

BEGIN {

}

}

<p>output:</p>

<pre>

inside odd 3

</pre>

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

@echo off

 

echo _func2 has been executed

exit /b

 

=={{header|C}}==

 

void repeat(void (*f)(void), unsigned int n) {

return 0;

}

 

{{trans|Java}}

 

namespace Repeat {

}

}

{{out}}

<pre>Example 1

Example 2

Example 3</pre>

 

=={{header|Clojure}}==

 

{{out}}

 

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

(dotimes (i n) (funcall f)))

 

 

=={{header|D}}==

foreach (immutable _; 0 .. times)

fun();

void main() {

repeat(&procedure, 3);

{{out}}

<pre>Example

Example

Example</pre>

 

=={{header|EchoLisp}}==

(define (repeat f n) (for ((i n)) (f)))

 

(cos 0.7390851332151605)

→ 0.7390851332151608 ;; fixed point found

 

=={{header|F#|F sharp}}==

 

let Repeat c f =

Repeat 3 Hello

 

 

=={{header|Factor}}==

Factor comes with the <tt>times</tt> word which does exactly this. For example,

{{out}}

<pre>

 

The implementation of <tt>times</tt>:

 

=={{header|Forth}}==

 

Or, taking care to keep the data stack clean for the XT's use, as is often desired:

 

 

Or as a novel control structure, which is not demanded by this task but which is just as idiomatic in Forth as the XT-consuming alternatives above:

 

 

Usage:

 

 

: 3-byes ( -- ) 3 times[ cr ." Bye" ]times ;

 

{{out}}<pre>Hello

 

=={{header|FreeBASIC}}==

 

Sub proc()

Print

Print "Press any key to quit"

 

{{out}}

4 proc called

5 proc called

</pre>

 

=={{header|Go}}==

 

import "fmt"

func main() {

repeat(4, fn)

 

=={{header|Haskell}}==

Such a function already exists

 

sampleFunction :: IO ()

sampleFunction = putStrLn "a"

 

 

And if the requirement is for something like a Church numeral, compounding the application of a given function '''n''' times (rather than repeating the same IO event '''n''' times) then we could also write something like '''applyN''' below:

applyN n f = foldr (.) id (replicate n f)

 

main :: IO ()

{{Out}}

<pre>1024</pre>

 

=={{header|J}}==

NB. ^: (J's power conjunction) repeatedly evaluates a verb.

 

hi

hi

 

=={{header|Java}}==

{{works with|Java|8}}

import java.util.stream.IntStream;

 

IntStream.range(0, n).forEach(i -> fun.accept(i + 1));

}

 

Output:

Example 2

Example 3</pre>

=={{header|jq}}==

{{works with|jq|1.4}}

 

'''Unoptimized version''':

if n <= 0 then empty

else f, repeat(f; n-1)

 

'''Optimized for TCO''':

# state: [count, in]

def r:

if .[0] >= n then empty else (.[1] | f), (.[0] += 1 | r) end;

'''Variant''':

# then emit a stream of (n + 1) terms: ., f, f|f, f|f|f, ...

def repeatedly(f; n):

else .[1], ([.[0] - 1, (.[1] | f)] | r)

end;

 

'''Examples''':

produces:

[1,1,1]

produces:

0

 

=={{header|Julia}}==

println("Hi")

end

end

 

{{out}}

<pre>Hi

 

=={{header|Kotlin}}==

 

fun repeat(n: Int, f: () -> Unit) {

fun main(args: Array<String>) {

repeat(5) { print("Example ") }

 

{{out}}

Example 4

Example 5

</pre>

 

=={{header|LiveCode}}==

 

command rep x,n

do merge("[[x]] [[n]]")

end repeat

 

=={{header|Lua}}==

No particular magic required as Lua allows functions to be passed as arguments.

print("Sure looks like a function in here...")

end

 

rep(myFunc, 4)

{{out}}

<pre>Sure looks like a function in here...

Sure looks like a function in here...</pre>

 

Note that anything of this form is not considered good practice.

{{out}}

<pre>Hello, world!

Hello, world!</pre>

 

 

=={{header|MiniScript}}==

 

print "Hi!"

end function

end function

 

{{out}}

<pre>Hi!

Hi!

Hi!</pre>

 

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

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

 

ReadChar

 

=={{header|Objeck}}==

 

function : Main(args : String[]) ~ Nil {

Repeat(Example() ~ Nil, 3);

"Example"->PrintLine();

}

 

=={{header|OCaml}}==

 

for i = 1 to n do

f ()

let () =

repeat ~n:4 ~f:func

 

=={{header|Oforth}}==

This method is already defined : times. This method can be used on all runnables (functions, methods, blocks, ...).

 

 

{{out}}

 

=={{header|Ol}}==

; sample function

(define (function) (display "+"))

(print) ; print newline

; ==> ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 

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

{{out}}

<pre>Hi!

Hi!</pre>

 

=={{header|Perl}}==

{{trans|C}}

 

my ($sub, $n) = @_;

$sub->() for 1..$n;

}

 

 

=={{header|Phix}}==

 

 

 

=={{header|PicoLisp}}==

 

# however, it has a slightly different syntax than what the

# problem specifies.

(do N (Fn)) )

 

 

=={{header|PowerShell}}==

{{trans|Python}} (Made more PowerShelly.)

function Out-Example

{

 

Step-Function Out-Example -Repeat 3

{{Out}}

<pre>

=={{header|Prolog}}==

 

repeat(Callable, Times) :-

succ(TimesLess1, Times),

 

test :- write('Hello, World'), nl.

{{out}}

<pre>

false.

</pre>

 

=={{header|Python}}==

 

===Procedural===

def repeat(f,n):

for i in range(n):

print("Example");

 

 

===Functional===

Repeated function application:

{{Works with|Python|3.7}}

 

from itertools import repeat

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Application of a given function, repeated N times:

(def h(x):

return 1.05 * x)(100) -> 115.7625</pre>

 

=={{header|R}}==

f1 <- function(...){print("coucou")}

 

 

f2(f1,4)

 

=={{header|Racket}}==

The racket guide has a section called [http://docs.racket-lang.org/guide/for.html?q=iterators "Iterators and Comprehensions"], which shows that ''for'' isn't just for repeating n times!

 

(define (repeat f n) ; the for loop is idiomatic of (although not exclusive to) racket

(for ((_ n)) (f)))

(display "...")

(repeat2 (λ () (display " & over")) 5)

{{out}}

<pre>... and over and over and over and over and over... & over & over & over & over & over</pre>

 

=={{header|REXX}}==

The procedure name (that is being repeatedly executed) isn't restricted to an &nbsp; ''internal'' &nbsp; REXX subroutine (procedure),

<br>it may be an &nbsp; ''external'' &nbsp; program (procedure) written in any language.

parse arg pN # . /*obtain optional arguments from the CL*/

if pN\=='' then call repeats pN, # /*invoke the REPEATS procedure for pN.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

repeats: procedure; parse arg x,n /*obtain the procedureName & # of times*/

return /*return to invoker of the REPEATS proc*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

<pre>

Yabba, yabba do!

 

=={{header|Ring}}==

Func Main

times(5,:test)

Call F()

next

 

=={{header|Ruby}}==

 

def repeat(proc,num)

end

 

 

=={{header|Rust}}==

}

}

 

}

 

fn main() {

 

 

 

=={{header|Scala}}==

# Type parameterization

# Higher order function

 

===Advanced Scala-ish ===

# Call by name

# Tail recursion

# Infix notation

implicit class IntWithTimes(x: Int) {

 

5 times println("ha") // Not recommended infix for 5.times(println("ha")) aka dot notation

 

===Most Scala-ish ===

# Infix notation

# Operator overloading

 

object Repeat3 extends App {

 

print("ha") * 5 // * is the method, effective should be A.*(5)

 

=={{header|Scheme}}==

an unspecified value. The actual value returned varies depending on the Scheme implementation itself.

 

(import (scheme base)

(scheme write))

;; example returning a number

(display (repeat (lambda () (+ 1 2)) 5)) (newline)

 

{{out}}

(#<undef> #<undef> #<undef> #<undef>)

(3 3 3 3 3)

</pre>

 

=={{header|Sidef}}==

{ f() } * n;

}

}

 

 

=={{header|Stata}}==

 

for (i=1; i<=n; i++) (*f)()

}

}

 

 

=={{header|Swift}}==

for _ in 0..<n {

f()

}

 

 

=={{header|Tcl}}==

The usual way of doing a repeat would be:

for {set i 0} {$i < $count} {incr i} {

uplevel 1 $command

 

proc example {} {puts "This is an example"}

However, the <code>time</code> command can be used as long as the return value (the report on the timing information) is ignored.

It should be noted that the “command” can be an arbitrary script, not just a call to a procedure:

 

=={{header|Ursa}}==

for (set n n) (> n 0) (dec n)

f

 

# outputs "Hello! " 5 times

 

=={{header|VBA}}==

For i = 1 To n

Application.Run rid

Public Sub main()

Repeat "Hello", 5

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

{{trans|C#}}

 

Sub Repeat(count As Integer, fn As Action(Of Integer))

End Sub

 

{{out}}

<pre>Example 1

Example 2

Example 3</pre>

 

=={{header|XLISP}}==

(f)

(if (> n 1)

 

;; an example to test it:

{{out}}

<pre>(HELLO ROSETTA CODE)

=={{header|Yabasic}}==

{{trans|Lua}}

print "Sure looks like a function in here..."

end sub

end sub

 

=={{header|zkl}}==

{{out}}<pre>ho ho ho </pre>