Question

I’m teaching myself to program in Haskell, and I’m working on a find function. What it does is it takes two strings, such as "hello" and "he", and it counts how many times "he" appears in "hello".

The find function needs to keep track of several things, such as how many times the word has been found in the list, that do not need to be entered at the start of the function. So, i broke the function up into two smaller functions: one that the user originally enters the data into, which then directs the data to a second function that does the work.

Here’s my code:

search :: (Eq a) => [a] -> [a] -> Integer
search [] _ = 0
search _ [] = 0
search x y = search1 x y y 0

search1 :: (Eq a) => [a] -> [a] -> [a] -> Integer -> Integer
search1 _ _ [] n = n
search1 x [] z n = search1 x z z (n+1)
search1 [] _ _ n = n
search1 (x:xs) (y:ys) z n
  | x == y = search1 xs ys z n
  | otherwise = search1 xs (y:ys) z n

In it, instead of the user starting out with the function search1, which needs some data that would be redundant for the user to enter, I created the function search to “plug in” the data to search1 for the user.

My question is, is creating a function to “plug in” redundant data a good practice in Haskell? Or should I be doing something different?

Answer 1

Yes, it is good practice. However, it is often better to make the second function local to the first, if it is not useful on its own and only serves as the worker for the other one.

If you create a worker local to the wrapper, you can refer to the wrapper’s arguments in the body of the worker without passing them as arguments to the worker, which often helps performance.

For your example, the function with a local worker could look like

search :: (Eq a) => [a] -> [a] -> Integer
search [] _ = 0
search _ [] = 0
search hay needle = search1 hay needle 0
  where
    search1 x [] n = search1 x needle (n+1)
    search1 [] _ n = n
    search1 (x:xs) (y:ys) n
      | x == y = search1 xs ys n
      | otherwise = search1 xs (y:ys) n

where I’ve eliminated one argument of the worker that was never changed in the recursive call. Also, making the worker local eliminates the need to check for an empty needle.