CloudFlare suffered a massive security issue affecting all of its customers, including Rosetta Code. All passwords not changed since February 19th 2017 have been expired, and session cookie longevity will be reduced until late March.--Michael Mol (talk) 05:15, 25 February 2017 (UTC)

Repeat

From Rosetta Code
Repeat is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task

Write a procedure which accepts as arguments another procedure and a positive integer.

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

Ada[edit]

with Ada.Text_IO;
 
procedure Repeat_Example is
 
procedure Repeat(P: access Procedure; Reps: Natural) is
begin
for I in 1 .. Reps loop
P.all; -- P points to a procedure, and P.all actually calls that procedure
end loop;
end Repeat;
 
procedure Hello is
begin
Ada.Text_IO.Put("Hello! ");
end Hello;
 
begin
Repeat(Hello'Access, 3); -- Hello'Access points to the procedure Hello
end Repeat_Example;

Output:

Hello! Hello! Hello! 

ALGOL 68[edit]

Works with: ALGOL 68G version 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:
TO count DO routine OD;
 
# make REPEAT a low priority operater #
PRIO REPEAT = 1;
 
 
# can also create variant that passes the iteration count as a parameter #
OP REPEAT = ( INT count, PROC( INT )VOID routine )VOID:
FOR iteration TO count DO routine( iteration ) OD;
 
main: (
 
# PROC to test the REPEAT operator with #
PROC say something = VOID: print( ( "something", newline ) );
 
3 REPEAT say something;
 
# PROC to test the variant #
PROC show squares = ( INT n )VOID: print( ( n, n * n, newline ) );
 
3 REPEAT show squares
 
)
 

Output:

something
something
something
         +1         +1
         +2         +4
         +3         +9

Applesoft BASIC[edit]

http://hoop-la.ca/apple2/2016/winterwarmup/#repeat.bas

AutoHotkey[edit]

repeat("fMsgBox",3)
return
 
repeat(f, n){
loop % n
%f%()
}
 
fMsgBox(){
MsgBox hello
}

AWK[edit]

 
# syntax: GAWK -f REPEAT.AWK
BEGIN {
for (i=0; i<=3; i++) {
f = (i % 2 == 0) ? "even" : "odd"
@f(i) # indirect function call
}
exit(0)
}
function even(n, i) {
for (i=1; i<=n; i++) {
printf("inside even %d\n",n)
}
}
function odd(n, i) {
for (i=1; i<=n; i++) {
printf("inside odd %d\n",n)
}
}
 

output:

inside odd 1
inside even 2
inside even 2
inside odd 3
inside odd 3
inside odd 3

C[edit]

#include <stdio.h>
 
void repeat(void (*f)(void), unsigned int n) {
while (n-->0)
(*f)(); //or just f()
}
 
void example() {
printf("Example\n");
}
 
int main(int argc, char *argv[]) {
repeat(example, 4);
return 0;
}
 

C++[edit]

template <typename Function>
void repeat(Function f, unsigned int n) {
for(unsigned int i=n; 0<i; i--)
f();
}

usage:

#include <iostream>
void example() {
std::cout << "Example\n";
}
 
repeat(example, 4);
Works with: C++11
 repeat([]{std::cout << "Example\n";}, 4);

Clojure[edit]

(defn repeat-function [f n] 
(dotimes [i n] (f)))
Output:
user=> (repeat-function #(println "bork") 3)
bork
bork
bork

Common Lisp[edit]

(defun repeat (f n)
(dotimes (i n) (funcall f)))
 
(repeat (lambda () (format T "Example~%")) 5)

D[edit]

void repeat(void function() fun, in uint times) {
foreach (immutable _; 0 .. times)
fun();
}
 
void procedure() {
import std.stdio;
"Example".writeln;
}
 
void main() {
repeat(&procedure, 3);
}
Output:
Example
Example
Example

EchoLisp[edit]

 
(define (repeat f n) (for ((i n)) (f)))
 
(repeat (lambda () (write (random 1000))) 5)
287 798 930 989 794
 
;; Remark
;; It is also possible to iterate a function : f(f(f(f( ..(f x)))))
(define cos10 (iterate cos 10)
(define cos100 (iterate cos10 10))
(cos100 0.6)
0.7390851332151605
(cos 0.7390851332151605)
0.7390851332151608 ;; fixed point found
 


Forth[edit]

: times ( xt n -- )
0 ?do dup execute loop drop ;

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

: times { xt n -- }
n 0 ?do xt execute loop ;

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:

: times[  ]] 0 ?do [[ ; immediate compile-only
: ]times postpone loop ; immediate compile-only

Usage:

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

Hello Hello Bye Bye

Bye

FreeBASIC[edit]

' FB 1.05.0 Win64
 
Sub proc()
Print " proc called"
End Sub
 
Sub repeat(s As Sub, n As UInteger)
For i As Integer = 1 To n
Print Using "##"; i;
s()
Next
End Sub
 
repeat(@proc, 5)
Print
Print "Press any key to quit"
Sleep
Output:
 1 proc called
 2 proc called
 3 proc called
 4 proc called
 5 proc called

Go[edit]

package main
 
import "fmt"
 
func repeat(n int, f func()) {
for i := 0; i < n; i++ {
f()
}
}
 
func fn() {
fmt.Println("Example")
}
 
func main() {
repeat(4, fn)
}

Haskell[edit]

Such a function already exists

import Control.Monad (replicateM_)
 
sampleFunction :: IO ()
sampleFunction = putStrLn "a"
 
main = replicateM_ 5 sampleFunction

J[edit]

 
NB. ^: (J's power conjunction) repeatedly evaluates a verb.
 
NB. Appending to a vector the sum of the most recent
NB. 2 items can generate the Fibonacci sequence.
 
(, [: +/ _2&{.) (^:4) 0 1
0 1 1 2 3 5
 
 
NB. Repeat an infinite number of times
NB. computes the stable point at convergence
 
cosine =: 2&o.
 
cosine (^:_ ) 2 NB. 2 is the initial value
0.739085
 
cosine 0.739085 NB. demonstrate the stable point x==Cos(x)
0.739085
 
 
cosine^:(<_) 2 NB. show the convergence
2 _0.416147 0.914653 0.610065 0.819611 0.682506 0.775995 0.713725 0.755929 0.727635 0.74675 0.733901 0.742568 0.736735 0.740666 0.738019 0.739803 0.738602 0.739411 0.738866 0.739233 0.738986 0.739152 0.73904 0.739116 0.739065 0.739099 0.739076 0.739091 0.7...
 
 
# cosine^:(<_) 2 NB. iteration tallyft
78
 
f =: 3 :'smoutput ''hi'''
 
f''
hi
 
NB. pass verbs via a gerund
repeat =: dyad def 'for_i. i.y do. (x`:0)0 end. EMPTY'
 
(f`'')repeat 4
hi
hi
hi
hi
 
 
 
NB. pass a verb directly to an adverb
 
Repeat =: adverb def 'for_i. i.y do. u 0 end. EMPTY'
 
f Repeat 4
hi
hi
hi
hi
 

Java[edit]

Works with: Java version 8
import java.util.function.Consumer;
import java.util.stream.IntStream;
 
public class Repeat {
 
public static void main(String[] args) {
repeat(3, (x) -> System.out.println("Example " + x));
}
 
static void repeat (int n, Consumer<Integer> fun) {
IntStream.range(0, n).forEach(i -> fun.accept(i + 1));
}
}

Output:

Example 1
Example 2
Example 3

jq[edit]

Works with: jq version 1.4

We first define "repeat" naively but in accordance with the task specification; we then define an optimized version that illustrates a general technique for taking advantage of jq's support for tail-call optimization (TCO).

Since jq is a purely functional language, repeat(f; n) is unlikely to be very useful so we define a similar filter, repeatedly(f; n), which generates n+1 terms: . (the input), f, f|f, ... ; that is, using conventional functional notation, it generates: x, f(x), f(f(x)), ...

Unoptimized version:

def unoptimized_repeat(f; n):
if n <= 0 then empty
else f, repeat(f; n-1)
end;

Optimized for TCO:

def repeat(f; n):
# state: [count, in]
def r:
if .[0] >= n then empty else (.[1] | f), (.[0] += 1 | r) end;
[0, .] | r;

Variant:

# If n is a non-negative integer,
# then emit a stream of (n + 1) terms: ., f, f|f, f|f|f, ...
def repeatedly(f; n):
# state: [count, in]
def r:
if .[0] < 0 then empty
else .[1], ([.[0] - 1, (.[1] | f)] | r)
end;
[n, .] | r;

Examples:

0 | [ repeat(.+1; 3) ]

produces: [1,1,1]

0 | repeatedly(.+1; 3)

produces:

0 
1 
2
3

Julia[edit]

function sayHi()
println("Hi")
end
 
function rep(f, n)
for i = 1:n f() end
end
 
rep(sayHi, 3)
Output:
Hi
Hi
Hi

Kotlin[edit]

// version 1.0.6
 
fun repeat(n: Int, f: () -> Unit) {
for (i in 1..n) {
f()
println(i)
}
}
 
fun main(args: Array<String>) {
repeat(5) { print("Example ") }
}
Output:
Example 1
Example 2
Example 3
Example 4
Example 5

LiveCode[edit]

rep "answer",3
 
command rep x,n
repeat n times
do merge("[[x]] [[n]]")
end repeat
end rep

Lua[edit]

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

function myFunc ()
print("Sure looks like a function in here...")
end
 
function rep (func, times)
for count = 1, times do
func()
end
end
 
rep(myFunc, 4)
 
Output:
Sure looks like a function in here...
Sure looks like a function in here...
Sure looks like a function in here...
Sure looks like a function in here...

Mathematica[edit]

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

repeat[f_, n_] := Do[f[], {n}];
repeat[Print["Hello, world!"] &, 5];
Output:
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!

МК-61/52[edit]

1	П4
 
3 ^ 1 6 ПП 09 С/П
 
П7 <-> П0 КПП7 L0 12 В/О
 
ИП4 С/П КИП4 В/О

Objeck[edit]

class Repeat {
function : Main(args : String[]) ~ Nil {
Repeat(Example() ~ Nil, 3);
}
 
function : Repeat(e : () ~ Nil, i : Int) ~ Nil {
while(i-- > 0) {
e();
};
}
 
function : Example() ~ Nil {
"Example"->PrintLine();
}
}

OCaml[edit]

let repeat ~f ~n =
for i = 1 to n do
f ()
done
 
let func () =
print_endline "Example"
 
let () =
repeat ~n:4 ~f:func
 

Oforth[edit]

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

: hello "Hello, World!" println ;
10 #hello times
Output:
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!
Hello, World!

PARI/GP[edit]

repeat(f, n)=for(i=1,n,f());
repeat( ()->print("Hi!"), 2);
Output:
Hi!
Hi!

Perl[edit]

Translation of: C
sub repeat {
my ($sub, $n) = @_;
$sub->() for 1..$n;
}
 
sub example {
print "Example\n";
}
 
repeat(\&example, 4);

Perl 6[edit]

sub repeat (&f, $n) { f() xx $n };
 
sub example { say rand }
 
repeat(&example, 3);
Output:
0.435249779778396
0.647701200726486
0.279289335968417
Of course, we could have just written
example() xx 3;
or even
(say rand) xx 3;
directly – the custom repeat subroutine is just here to satisfy the task description.

Notes on the xx operator:

  • Unlike other operators, it evaluates its left-hand-side argument lazily - that's why we can simply call f() there rather than passing it as a function object.
  • The operator has a return value: A list consisting of the return values of the left-hand-side (and building lists is in fact what xx is usually used for).

General notes:

  • The & sigil in the repeat subroutine signature restricts that parameter to types that implement the Callable role, and makes it available inside the repeat subroutine body as if it were a lexically scoped sub.
  • The parentheses in the last line are necessary to disambiguate it as a call to our custom subroutine, rather than an attempt to use the built-in repeat { ... } while ... construct.

PicoLisp[edit]

# The built-in function "do" can be used to achieve our goal,
# however, it has a slightly different syntax than what the
# problem specifies.
 
# Native solution.
(do 10 (version))
 
# Our solution.
(de dofn (Fn N)
(do N (Fn)) )
 
(dofn version 10)

PowerShell[edit]

Translation of: Python
(Made more PowerShelly.)
 
function Out-Example
{
"Example"
}
 
function Step-Function ([string]$Function, [int]$Repeat)
{
for ($i = 1; $i -le $Repeat; $i++)
{
"$(Invoke-Expression -Command $Function) $i"
}
}
 
Step-Function Out-Example -Repeat 3
 
Output:
Example 1
Example 2
Example 3

Python[edit]

#!/usr/bin/python
def repeat(f,n):
for i in range(n):
f();
 
def procedure():
print("Example");
 
repeat(procedure,3); #prints "Example" (without quotes) three times, separated by newlines.

R[edit]

 
f1 <- function(...){print("coucou")}
 
f2 <-function(f,n){
lapply(seq_len(n),eval(f))
}
 
f2(f1,4)
 

Racket[edit]

The racket guide has a section called "Iterators and Comprehensions", which shows that for isn't just for repeating n times!

#lang racket/base
(define (repeat f n) ; the for loop is idiomatic of (although not exclusive to) racket
(for ((_ n)) (f)))
 
(define (repeat2 f n) ; This is a bit more "functional programmingy"
(when (positive? n) (f) (repeat2 f (sub1 n))))
 
(display "...")
(repeat (λ () (display " and over")) 5)
(display "...")
(repeat2 (λ () (display " & over")) 5)
(newline)
Output:
... and over and over and over and over and over... & over & over & over & over & over

REXX[edit]

The procedure name (that is being repeatedly executed) isn't restricted to an   internal   REXX subroutine (procedure),
it may be an   external   program (procedure) written in any language.

/*REXX program   executes   a  named procedure  a specified number of times.            */
parse arg pN # . /*obtain optional arguments from the CL*/
if #=='' | #=="," then #=1 /*assume once if not specified. */
if pN\=='' then call repeats pN, # /*invoke the REPEATS procedure for pN.*/
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
repeats: procedure; parse arg x,n /*obtain the procedureName & # of times*/
do n; interpret 'CALL' x; end /*repeat the invocation N times. */
return /*return to invoker of the REPEATS proc*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
yabba: say 'Yabba, yabba do!'; return /*simple code; no need for PROCEDURE.*/

output when the input is:   yabba 4

Yabba, yabba do!
Yabba, yabba do!
Yabba, yabba do!
Yabba, yabba do!

output when the input is:   $date 3

[The (external)   $DATE.REX   program isn't supplied here.]

day-of-year= 159                Gregorian date= 06/08/2014               Sunday
day-of-year= 159                Gregorian date= 06/08/2014               Sunday
day-of-year= 159                Gregorian date= 06/08/2014               Sunday

Ring[edit]

 
Func Main
times(5,:test)
 
Func Test
see "Message from the test function!" + nl
 
Func Times nCount, F
for x = 1 to nCount
Call F()
next
 

Ruby[edit]

4.times{ puts "Example" }  # idiomatic way
 
def repeat(proc,num)
num.times{ proc.call }
end
 
repeat(->{ puts "Example" }, 4)

Rust[edit]

// Repeat the function f, n times.
fn repeat<F>(f: &F, n: u32)
where F: Fn() {
for _ in 0..n {
f();
}
}
 
fn static_fn() {
print!("Static ");
}
 
fn main() {
// Repeat a static function.
repeat(&static_fn, 4);
 
println!("");
 
// Repeat an anonymous closure.
repeat(&|| print!("Closure "), 5);
}
Output:
Static Static Static Static
Closure Closure Closure Closure Closure

Scala[edit]

Intuitive solution[edit]

  1. Call by name
  2. Type parameterization
  3. Higher order function
  def repeat[A](n:Int)(f: => A)= ( 0 until n).foreach(_ => f)
 
repeat(3) { println("Example") }

Advanced Scala-ish[edit]

  1. Call by name
  2. Type parameterization
  3. Implicit method
  4. Tail recursion
  5. Infix notation
object Repeat2 extends App {
 
implicit class IntWithTimes(x: Int) {
def times[A](f: => A):Unit = {
@tailrec
def loop( current: Int): Unit =
if (current > 0) {
f
loop(current - 1)
}
loop(x)
}
}
 
5 times println("ha") // Not recommended infix for 5.times(println("ha")) aka dot notation
}

Most Scala-ish[edit]

  1. Call by name
  2. Type parameterization
  3. Implicit method
  4. Tail recursion
  5. Infix notation
  6. Operator overloading
import scala.annotation.tailrec
 
object Repeat3 extends App {
 
implicit class UnitWithNtimes(f: => Unit) {
def *[A](n: Int): Unit = { // Symbol * used instead of literal method name
@tailrec
def loop(current: Int): Unit =
if (current > 0) {
f
loop(current - 1)
}
loop(n)
}
}
 
print("ha") * 5 // * is the method, effective should be A.*(5)
}

Scheme[edit]

Scheme is mostly made up from expressions which return values. However some functions, such as display, return an unspecified value. The actual value returned varies depending on the Scheme implementation itself.

 
(import (scheme base)
(scheme write))
 
(define (repeat proc n)
(do ((i 0 (+ 1 i))
(res '() (cons (proc) res)))
((= i n) res)))
 
;; example returning an unspecified value
(display (repeat (lambda () (display "hi\n")) 4)) (newline)
 
;; example returning a number
(display (repeat (lambda () (+ 1 2)) 5)) (newline)
 
Output:

(Using chibi-scheme: returns #<undef> from display.)

hi
hi
hi
hi
(#<undef> #<undef> #<undef> #<undef>)
(3 3 3 3 3)

Sidef[edit]

func repeat(f, n) {
{ f() } * n;
}
 
func example {
say "Example";
}
 
repeat(example, 4);

Swift[edit]

func repeat(n: Int, f: () -> ()) {
for _ in 0..<n {
f()
}
}
 
repeat(4) { println("Example") }

Tcl[edit]

The usual way of doing a repeat would be:

proc repeat {command count} {
for {set i 0} {$i < $count} {incr i} {
uplevel 1 $command
}
}
 
proc example {} {puts "This is an example"}
repeat example 4

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

time example 4

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

repeat {puts "hello world"} 3

Ursa[edit]

def repeat (function f, int n)
for (set n n) (> n 0) (dec n)
f
end for
end repeat
 
def procedure ()
out "Hello! " console
end procedure
 
# outputs "Hello! " 5 times
repeat procedure 5

XLISP[edit]

(defun repeat (f n)
(f)
(if (> n 1)
(repeat f (- n 1)) ) )
 
;; an example to test it:
(repeat (lambda () (print '(hello rosetta code))) 5)
Output:
(HELLO ROSETTA CODE) 
(HELLO ROSETTA CODE) 
(HELLO ROSETTA CODE) 
(HELLO ROSETTA CODE) 
(HELLO ROSETTA CODE)

zkl[edit]

fcn repeat(f,n){ do(n){ f() } }
repeat("ho ".print,3);
Output:
ho ho ho