How can we limit recursive calls in Haskell?

Question

I've got a problem with my code, which is the following:

import Data.List

splitat _ [] = ([],[])
splitat element (head:tail)
  | element == head = ([],(head:tail))
  | otherwise = ([head]++fst(splitat element tail), snd(splitat element tail))

It splits a list at 'element', then combining the left and right sublist into a tuple. However, in the third line, the 'splitat element tail' command is called twice, once through 'fst' and once through 'snd'. Is there a way to evaluate this term only 1 time to keep the recursion tree narrow?

Thanks in advance.

Answer 1

Yes. You can make use of a let expression, or a where clause. For example:

splitat :: Eq a => a -> [a] -> ([a], [a])
splitat _ [] = ([],[])
splitat x' xa@(x:xs) | x == x' = ([], xa)
                     | otherwise = (x:ys1, ys2)
    where (ys1, ys2) = splitat x' xs

Note: please do not use head :: [a] -> a or tail :: [a] -> [a] or other functions that are defined as variables, since these will shadow the existing binding. It makes it harder to reason about the code, since a person might think that head and tail refer to these functions, and not the variables.