How to call the same function 'n' times? [duplicate]

Answer 1

f 0 = l
f n = g (f (n-1))

But more functional would be:

f 0 l = l
f n l = g (f (n-1) l)

This could also be done with folds or morfisms, but this is easier to understand.

For example here's using a hylomorphism, but it doesn't make it clearer really:

f g l = hylo l (.) (\n -> (g, n-1)) (==0)

It says some thing like compose (.) g(l) until n==0

Answer 2

iterate is a common solution:

> :t iterate
iterate :: (a -> a) -> a -> [a]

So, given a function with a domain the same as its range, a -> a, and an initial input a, produce an infinite list of results in the form:

iterate f a --> [a, f(a), f(f(a)), ...]

And you can access the nth element of the list using !!:

iterate f a !! n

NB iterate f a !! 0 == a.

Answer 3

This is a function that I use often at the ghci prompt. There are a few ways to write it, none of which I am particularly fond of, but they are all reasonably clean:

fpow n f x = iterate f x !! n

fpow n f = foldr (.) id $ replicate n f

fpow n = foldr (.) id . replicate n   -- just eta the above

fpow 0 f = id
fpow n f = f . fpow (n-1) f

The middle two appeal to me because my brain has chunked foldr (.) id to mean "compose a list of functions".

I kinda just wish it were in the prelude :-).

Answer 4

Can be done using fold:

applyNTimes :: Int -> (a -> a) -> a -> a
applyNTimes n f val = foldl (\s e -> e s) val [f | x <- [1..n]]