Iteration using counters in functional programming?

Question

I'm iterating through a list of [Char], I'm wondering the best way to perform the iteration.

This function calls itself recursively and passes back to itself a counter that gets decreased per iteration.

Its just for illustrative purposes, so always return True for each Char:

text = ["abcsdsdsdsd"]

exampleFunction :: Int -> String -> [Bool]
exampleFunction textlen text
  | textlen >= 0        = True : exampleFunction (textlen - 1) text
  | otherwise   = []

Using 'textlen' as a counter seems rather imperative, is this the best way and/or the most Haskell-like to implement this?

Depends on what's your purpose. For example, if you have a list of Ints and want to get the result out of it you can use fold. Or if you want to apply a function to every element of the list you can use map or generalized one that you can apply to Haskell data type such as Maybe, Either, etc. you can use fmap. Take a look at Functor type class. Functor is for those data types that can be mapped over which list is one of the data types. Based on your example you can for example use map _ -> True yourlist — Ch0k0l8
– Ch0k0l8, Commented Oct 12, 2016 at 11:09
"abcsdsdsdsd" is equivalent to ['a', 'b', 'c', 's', 'd', 's', 'd', 's', 'd', 's', 'd']. — chepner
– chepner, Commented Oct 12, 2016 at 11:49

chepner · Accepted Answer · 2016-10-12 12:34:47Z

The counter isn't necessary. The length of the list isn't particularly important; you just use it to determine if the list is non-empty (textlen >= 0) or not. You can do the same thing by pattern matching on the argument itself.

exampleFunction :: [String] -> [Bool]
exampleFunction (x:xs) = True : exampleFunction xs
exampleFunction []  = []

As pointed out in a comment, this particular recursion scheme is abstracted out as the map function:

exampleFunction :: [String] -> [Bool]
exampleFunction xs = map (const True) xs

where const True returns a function that returns True no matter what its argument is. (const True can also be written as an explicit lambda expression (\_ -> True). map applies this function to each element of xs and combines the results into a new list.

Other recursion schemes capture different styles of recursion (filter, foldr, etc), so while it is always possible to write an explicit recursive function to accomplish your task, you can often avoid it by using the appropriate higher order function.

I'm abusing the term recursion scheme a bit; map and filter can be thought of as special cases of foldr, which is an example of a general recursion scheme known as a catamorphism.

Collectives™ on Stack Overflow

Iteration using counters in functional programming?

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related