Repeat: Difference between revisions

{{trans|Python}}

L 1..n

f()

print(‘Example’)

{{out}}

This routine is a bit messy, and assumes the called routine doesn't clobber the zero-page memory used to maintain it. This can be modified to push/pop those values before/after the routine is executed.

; input:

; addr = the label of the routine you wish to call repeatedly

;JMP (z_L) and it will automatically replace it with the above during the assembly process.

;This causes an indirect JMP to the routine. Its RTS will return execution to just after the "JSR Trampoline_RepeatProc"

Once the macro and the underlying subroutine are created, this is very simple to use:

===Using self-modifying code===

This version requires that your "wrapper" executes in RAM, so that it can be modified. For this to work, it is assumed that the routine you're using doesn't clobber Y, or require that its parameters are passed in by A or X (so admittedly this method is a bit limited, but if you use the zero page to hold the parameters you can set them up prior to calling the wrapper itself.

;input: low byte of desired function address in A

; high byte of desired function address in X

dey

bne smc_repeatproc

=={{header|68000 Assembly}}==

This example code prints an exclamation point to the screen 4 times.

It is assumed that the functions called do not clobber A5 or D7, as doing so would cause undefined behavior (read: a crash or a program counter "escape.")

move.w #4-1,d7 ;times to repeat

jsr Repeater

MOVE.B #'!',D0

JSR PrintChar

{{out}}

=={{header|Action!}}==

PROC OutputText(CHAR ARRAY s)

PROC Main()

Repeat(OutputText,"Action!",5)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Repeat.png Screenshot from Atari 8-bit computer]

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

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

@echo off

echo _func2 has been executed

exit /b

=={{header|BQN}}==

BQN has a builtin called Repeat which fulfills the criteria for the challenge(and allows multiple iteration counts), hence there is a recursive implementation of repeat added in as well.

_repeat_ ← {(𝕘>0)◶⊢‿(𝔽_𝕣_(𝕘-1)𝔽)𝕩}

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

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

It runs on Lean 3.4.2:

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

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

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

type

begin

Iterate(P, 3);

{{out}}

<pre>Iteration 1

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

=={{header|Red}}==

myrepeat: function [fn n] [loop n [do fn]]

{{out}}

<pre>

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

=={{header|Seed7}}==

const proc: myRepeat (in integer: times, in proc: aProcedure) is func

begin

myRepeat(3, writeln("Hello!"));

{{out}}

<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|uBasic/4tH}}==

_Repeat Param (2) : Local (1) : For c@ = 1 To b@ : Proc a@ : Next : Return

Output:

<pre>

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

initial begin

repeat(5) begin

$display("Loop Ended");

end

{{out}}

<pre>Inside loop

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

{{trans|C#}}

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

End Sub

{{out}}

<pre>Example 1

=={{header|Vlang}}==

for _ in 0.. n {

f()

fn main() {

repeat(4, func)

{{out}}

<pre>Example

=={{header|Wren}}==

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

}

}

{{out}}

=={{header|XBS}}==

XBS has a built-in repeat keyword.

repeat amount {

callback(*args);

rep(func(a,b,c){

log(a+b+c);

{{out}}

<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|Z80 Assembly}}==

This technique is called the "Return Trick", it's efficient but makes the program more difficult to read. It works on the principle that the processor's RET command assumes the return address is the top item of the stack. The programmer can abuse this to "return" to a section of code that has never actually been executed. This is essentially just another form of the computed goto. Most processors that use the stack to store return addresses can use this technique, though the method of doing it depends on the processor itself.

ld b,&05 ;load the decrement value into b

ld hl,myFunc ;load the address of "myFunc" into HL

pop hl

ret

=== Indirect Jump ===

Same as above but uses an indirect jump to the address in HL.

===Using self-modifying code===

call &0000 ;gets overwritten with the address of MyFunc

djnz repeatProc

=={{header|zkl}}==

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