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.

The task is to 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.

C

<lang c>#include <stdio.h>

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

for(int i=n; 0<i; i--)
(*f)();

}

void example() {

printf("Example\n");

}

void main(char *argv[], int argc) {

repeat(example, 4);

}</lang>

Common Lisp

<lang lisp>(defun repeat (f n)

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

(repeat (lambda () (format T "Example~%")) 5)</lang>

D

<lang d>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);

}</lang>

Output:
Example
Example
Example

Go

<lang go>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)

}</lang>

Haskell

Such a function already exists <lang Haskell>import Control.Monad (replicateM_)

sampleFunction :: IO () sampleFunction = putStrLn "a"

main = replicateM_ 5 sampleFunction</lang>

J

<lang J>

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

Java

Works with: Java version 8

<lang java>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));
   }

}</lang>

Output:

Example 1
Example 2
Example 3

МК-61/52

<lang>1 П4

3 ^ 1 6 ПП 09 С/П

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

ИП4 С/П КИП4 В/О</lang>

OCaml

<lang ocaml>let repeat ~f ~n =

 for i = 1 to n do
   f ()
 done

let func () =

 print_endline "Example"

let () =

 repeat ~n:4 ~f:func

</lang>

PARI/GP

<lang parigp>repeat(f, n)=for(i=1,n,f()); repeat( ()->print("Hi!"), 2);</lang>

Output:
Hi!
Hi!

Perl

Translation of: C

<lang perl>sub repeat {

   my ($sub, $n) = @_;
   $sub->() for 1..$n;

}

sub example {

   print "Example\n";

}

repeat(\&example, 4);</lang>

Perl 6

<lang perl6>sub repeat (&f, $n) { f() xx $n };

sub example { say rand }

repeat(&example, 3);</lang>

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.

Python

<lang Python>#!/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.</lang>

Racket

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

<lang Racket>#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)</lang>

Output:
... and over and over and over and over and over... & over & over & over & over & over

REXX

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. <lang rexx>/*REXX program executes a named procedure a specified number of times.*/ parse arg pN # . /*obtain optional parms from C.L.*/ if #== then #=1 /*assume once if not specified.*/ if pN\== then call repeats pN,# /*invoke the REPEATS procedure.*/ exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────REPEATS subroutine──────────────────*/ repeats: procedure; parse arg x,n /*get procedureName & # of times.*/

        do n; interpret 'CALL' x; end /*repeat the invocation  N times.*/

return /*return to invoker of REPEATS. */ /*──────────────────────────────────YABBA subroutine────────────────────*/ yabba: procedure; say 'Yabba, yabba do!'; return</lang> 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

Ruby

<lang ruby>4.times{ puts "Example" } # idiomatic way

def repeat(proc,num)

 num.times{ proc.call }

end

repeat(->{ puts "Example" }, 4)</lang>

Scala

Intuitive solution

  1. Call by name
  2. Type parameterization
  3. Higher order function

<lang scala> def repeat[A](n:Int)(f: => A)= ( 0 until n).foreach(_ => f)

 repeat(3) { println("Example") }</lang>

Advanced Scala-ish

  1. Call by name
  2. Type parameterization
  3. Implicit method
  4. Tail recursion
  5. Infix notation

<lang scala>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

}</lang>

Most Scala-ish

  1. Call by name
  2. Type parameterization
  3. Implicit method
  4. Tail recursion
  5. Infix notation
  6. Operator overloading

<lang scala>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) 

}</lang>

Swift

<lang swift>func repeat(n: Int, f: () -> ()) {

 for _ in 0..<n {
   f()
 }

}

repeat(4) { println("Example") }</lang>

Tcl

The usual way of doing a repeat would be: <lang tcl>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</lang> However, the time command can be used as long as the return value (the report on the timing information) is ignored. <lang tcl>time example 4</lang> It should be noted that the “command” can be an arbitrary script, not just a call to a procedure: <lang tcl>repeat {puts "hello world"} 3</lang>