Repeat: Difference between revisions

{{trans|Python}}

 

L 1..n

f()

print(‘Example’)

 

 

{{out}}

Example

Example

</pre>

 

=={{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>

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

As well as the names of procedures, Algol W allows statements to be passed as parameters where a procedure is expected.

% executes the procedure routine the specified number of times %

procedure repeat ( integer value count; procedure routine ) ;

)

end

{{out}}

<pre>

 

=={{header|AppleScript}}==

on applyN(n, f, x)

script go

end repeat

return out & dbl

{{Out}}

<pre>(*1024*)

 

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

 

=={{header|Arturo}}==

print "As a loop"

print "---------------------------"

print "With a function param"

print "---------------------------"

 

{{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;

}

 

=={{header|C sharp|C#}}==

{{trans|Java}}

 

namespace Repeat {

}

}

{{out}}

<pre>Example 1

 

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

void repeat(Function f, unsigned int n) {

for(unsigned int i=n; 0<i; i--)

f();

usage:

void example() {

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

}

 

{{works with|C++11}}

 

=={{header|Clojure}}==

 

{{out}}

 

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

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

 

 

=={{header|Cowgol}}==

 

# Only functions that implement an interface can be passed around

# Prints "foo foo foo foo"

Repeat(Foo, 4);

 

=={{header|D}}==

foreach (immutable _; 0 .. times)

fun();

void main() {

repeat(&procedure, 3);

{{out}}

<pre>Example

 

=={{header|Delphi}}==

program Repeater;

 

end.

 

 

Alternative

 

program Repeater;

 

readln;

end.

 

 

 

=={{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|Gambas}}==

Note: Gambas (3.14.0) cannot perform this task as specified, as it does not have delegates, and pointers do not seem to work with procedures. What does work is using Object.Call, which is intended for executing procedures from external libraries. However the accepting procedure must refer to the object containing the procedure, and refer to the procedure by a String name. In this case, the current module/class reference (Me) is used, but the String name must be passed. This arrangement will only work within the same module/class. It may be possible to pass the parent reference to a method (taking 3 parameters) in another class if the named procedure is Public. The empty array ([]) in Object.Call represent a procedure without parameters, which are not an explicit requirement for this Task, but might require another parameter to the accepting procedure.

Public Sub Main()

 

Print "RepeatableTwo"

 

Output:

<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|Isabelle}}==

Isabelle does not have procedures with side effects. So we cannot do things such as printing a string to stdout. Isabelle only has pure mathematical functions.

imports Main

begin

lemma "fun_repeat (λ_. a) n = repeat a n" by(induction n) simp+

 

 

=={{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:

 

'''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}}

=={{header|Lean}}==

 

| 0 f := "done"

| (n + 1) f := (f n) ++ (repeat n f)

 

#eval repeat 5 $ λ b : ℕ , "me "

 

=={{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!

This operator already exists in min and is called <code>times</code>.

{{works with|min|0.19.6}}

{{out}}

<pre>

=={{header|MiniScript}}==

 

print "Hi!"

end function

end function

 

{{out}}

<pre>Hi!

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

 

 

3 ^ 1 6 ПП 09 С/П

П7 <-> П0 КПП7 L0 12 В/О

 

 

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

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

 

ReadChar

 

=={{header|Nanoquery}}==

{{trans|Python}}

for i in range(1, n)

f()

end

 

 

=={{header|Nim}}==

echo "Example"

 

repeatMacro 4:

example()

 

=={{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}}==

<span style="color: #008080;">procedure</span> <span style="color: #000000;">Repeat</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">rid</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">n</span> <span style="color: #008080;">do</span>

<span style="color: #000000;">Repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">Hello</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>

 

=={{header|Phixmonti}}==

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

enddef

 

getid myFunc 4 rep

 

=={{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>

 

=={{header|PureBasic}}==

 

Procedure.i quark(z.i)

EndProcedure

 

{{out}}

<pre>Quark 3

 

===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:

The word ''rosetta-times'' is also defined here, using ''times''. It takes both the repeat number and the function as stack arguments.

 

protect times.start

 

 

[ nested ' times nested

 

{{Out}}

 

=={{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>

(formerly Perl 6)

 

 

sub example { say rand }

 

 

{{Out}}

* The <code>&</code> sigil in the <code>repeat</code> subroutine signature restricts that parameter to types that implement the <code>Callable</code> role, and makes it available inside the <code>repeat</code> 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 <code>repeat { ... } while ...</code> construct.

 

=={{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 #=='' | #=="," then #= 1 /*assume once if not specified. */

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

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

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> yabba &nbsp; 4 </tt>}}

<pre>

 

=={{header|Ring}}==

Func Main

times(5,:test)

Call F()

next

 

=={{header|Ruby}}==

 

def repeat(proc,num)

end

 

 

=={{header|Rust}}==

Rust has higher-order functions.

 

(0..n).for_each(f);

 

Here we define the function <code>repeat</code> which takes the function <code>Fn(usize)</code>, which is an anonymous trait constraint by the <code>impl Trait</code> syntax, in such a way that it's size can be known statically at compile time. The range iterator <code>0..n</code> is used, in combination with the <code>Iterator::for_each</code> method to consume it.

It's idiomatic to use a closure.

 

repeat(|x| print!("{};", x), 5);

{{out}}<pre>0;1;2;3;4;</pre>

 

Also possible to define a static function.

 

print!("{};", x);

}

fn main() {

repeat(function, 4);

 

{{out}}<pre>0;1;2;3;</pre>

Sometimes it may be convenient to call a static method.

 

impl Foo {

fn associated(x: usize) {

fn main() {

repeat(Foo::associated, 8);

{{out}}<pre>0;1;2;3;4;5;6;7;</pre>

 

You can also use implemented trait-methods as a function-argument. This works because the implemented type is <code>usize</code> which is what the iterator supplied to <code>Fn(usize)</code>.

 

fn run(self);

}

fn main() {

repeat(Bar::run, 6);

{{out}}<pre>0;1;2;3;4;5;</pre>

 

The most interesting application would probably be a mutable closure, which requires changing the type signature from <code>Fn</code> to <code>FnMut</code>, because they are constrained by slightly different rules, but otherwise work the same.

 

(0..n).for_each(f);

}

mult += x;

}, 5);

{{out}}<pre>0;1;4;12;28;</pre>

 

# 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|Standard ML}}==

| repeat (f, n) = (f (); repeat (f, n - 1))

 

print "test\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|Wren}}==

for (i in 1..n) g.call(n)

}

}

 

 

{{out}}

1 2 3 4 5

1 2 3 4 5

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