Repeat: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|Java}}: use iota-like construct)
(add Perl)
Line 170: Line 170:
<pre>Hi!
<pre>Hi!
Hi!</pre>
Hi!</pre>

=={{header|Perl}}==

{{trans|C}}

<lang perl>sub repeat {
my ($sub, $n) = @_;
$sub->() for 1..$n;
}

sub example {
print "Example\n";
}

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


=={{header|Perl 6}}==
=={{header|Perl 6}}==

Revision as of 16:27, 29 June 2014

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

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

Perl 6 has a built in infix repeat operator (xx) that does this. It returns a list of whatever is on the left side (string, function, subroutine, whatever) times whatever integer is on the right. Nominally it is for building lists but can be used for side effects too. It could be argued that this is an operator, not a procedure, but in Perl 6, operators are just subroutines with funny calling conventions.

Print a list consisting of repeated strings. <lang Perl6>say <Again> xx 4;</lang>

Output:
   Again Again Again Again

Use it for side effects. Execute the code inside the parenthesis repeatedly. <lang Perl6>(say <Again>) xx 3;</lang>

Output:
   Again
   Again
   Again

Print a list built by executing the built in rand function repeatedly. <lang Perl6>say rand xx 5;</lang>

Output:
   0.313024826146821 0.231583221230768 0.439756228609952 0.870180182595826 0.650911888509852

Create a small subroutine, call it repeatedly then print the result. <lang Perl6>sub boguscode () { sleep 1; time; } my @times = boguscode() xx 4; say @times;</lang>

Output:
   1400450920 1400450921 1400450922 1400450923

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>

Retrieved from "https://rosettacode.org/wiki/Repeat?oldid=246928"