Repeat: Difference between revisions
(→{{header|Java}}: added Java) |
(added swift) |
||
Line 300: | Line 300: | ||
print("ha") * 5 // * is the method, effective should be A.*(5) |
print("ha") * 5 // * is the method, effective should be A.*(5) |
||
}</lang> |
}</lang> |
||
=={{header|Swift}}== |
|||
<lang swift>func repeat(n: Int, f: () -> ()) { |
|||
for _ in 0..n { |
|||
f() |
|||
} |
|||
} |
|||
repeat(4) { println("Example") }</lang> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
Revision as of 07:58, 29 June 2014
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
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
<lang java>import java.util.function.Consumer;
public class Repeat {
public static void main(String[] args) { repeat(3, (x) -> System.out.println("Example " + x)); }
static void repeat (int times, Consumer<Integer> block) { for (int i = 0; i < times; i++) block.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 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
- Call by name
- Type parameterization
- 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
- Call by name
- Type parameterization
- Implicit method
- Tail recursion
- 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
- Call by name
- Type parameterization
- Implicit method
- Tail recursion
- Infix notation
- 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>