Haskell replace characters in string

How about:

let 
    repl 'o' = 'x'
    repl  c   = c
in  map repl "Hello World"

If you need to replace additional characters later, just add clauses to the repl function.

Alternative 1 - Using MissingH

First:

import Data.List.Utils (replace)

Then use:

replace "O" "X" "HELLO WORLD"

Alternative 2 - Using Control.Monad

One funny bastard:

import Control.Monad (mfilter)

replace a b = map $ maybe b id . mfilter (/= a) . Just

Example:

λ> replace 'O' 'X' "HELLO WORLD"
"HELLX WXRLD"

Alternative 3 - Using if

Amon's suggestions was probably the finest I believe! No imports and easy to read and understand!

But to be picky - there's no need for semicolon:

replace :: Eq a => a -> a -> [a] -> [a]
replace a b = map $ \c -> if c == a then b else c

Sorry for picking up this old thread but why not use lambda expressions?

λ> let replaceO = map (\c -> if c=='O' then 'X'; else c)
λ> replaceO "HELLO WORLD"
"HELLX WXRLD"`

If you depend on the text package (like 99.99% of Haskell applications), you can use T.replace:

>>> replace "ofo" "bar" "ofofo"
"barfo"

Here's another possible solution using divide and conquer:

replaceO [] = []
replaceO (x:xs) = 
     if x == 'O' 
     then 'X' : replaceO xs 
     else x : replaceO xs

First, you set the edge condition "replaceO [] = []".
If the list is empty, there is nothing to replace, returning an empty list.

Next, we take the string and divide it into head and tail. in this case 'H':"ELLOWORLD"
If the head is equal to 'O', it will replace it with 'X'. and apply the replaceO function to the rest of the string.
If the head is not equal to 'O', then it will put the head back where it is and apply the replaceO function to the rest of the string.

replace :: Char -> Char -> String -> String
replace _ _ [] = []
replace a b (x : xs) 
                  | x == a = [b] ++ replace a b xs
                  | otherwise = [x] ++ replace a b xs

I'm new to Haskell and I've tried to make it simpler for others like me.

I guess this could be useful.

main = print $ charRemap "Hello WOrld" ['O','o'] ['X','x']

charRemap :: [Char] -> [Char] -> [Char] -> [Char]
charRemap [] _ _ = []
charRemap (w:word) mapFrom mapTo =
    if snd state
        then mapTo !! fst state : charRemap word mapFrom mapTo
        else w : charRemap word mapFrom mapTo
    where
        state = hasChar w mapFrom 0

hasChar :: Char -> [Char] -> Int -> (Int,Bool)
hasChar _ [] _ = (0,False)
hasChar c (x:xs) i | c == x = (i,True)
                   | otherwise = hasChar c xs (i+1)