Question

How can I do a function (recursivily) that substitute the argument b(1) for an argument a(0) on a list?
For example:

    substitute 0 1 [1,0,3,0,4,0,0]
    [1,1,3,1,4,1,1]

Thanks.

Answer 1

The simplest is to use list comprehension:

subst a b xs = [c | x<-xs, let c=if x==a then b else x].

But that’s no recursion. With recursion, it is just a case analysis for list structure (i.e. structural recursion):

subst a b [] = []
subst a b (x:xs) 
   | x==a      = b:subst a b xs
   | otherwise = x:subst a b xs

which is an instance of the foldr (or map) pattern:

subst a b = foldr (\x xs-> (if x==a then b else x) : xs) [] 
subst a b = map   (\x   ->  if x==a then b else x      ) 

It is usually advisable to use a “worker” function in recursive definitions, like so:

subst a b xs = go xs
  where
    go [] = []
    go (x:xs) 
       | x==a      = b:go xs
       | otherwise = x:go xs

but if you stare at it for a moment you recognize that it is follows the map pattern. In Haskell recursive patterns are captured by higher-order functions, like map, filter etc.