不如这样：

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

如果以后需要替换其他字符，只需向repl函数添加子句即可。

抱歉，我又提起了这个老主题，但为什么不使用lambda表达式呢？

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

• • 备选方案1-使用MissingH**

第一：

import Data.List.Utils (replace)

然后使用：

replace "O" "X" "HELLO WORLD"

• • 备选方案2-使用对照单胞菌**

一个有趣的混蛋：

import Control.Monad (mfilter)

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

示例：

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

• • 备选案文3-如果**

阿蒙的建议可能是最好的，我相信!没有进口和易于阅读和理解!
但要挑剔-有没有分号的必要：

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

下面是另一个使用分治法的可能解决方案：

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

首先，设置边界条件"replaceO [] = []"。
如果列表为空，则没有要替换的内容，并返回空列表。
接下来，我们将字符串分为head和tail，在本例中为'H':"ELLOWORLD"
如果头等于'O'，它将用'X'替换它，并对字符串的其余部分应用replaceO函数。
如果头不等于'O'，那么它会把头放回原处，并对字符串的其余部分应用replaceO函数。

如果您依赖于text包（像99.99%的Haskell应用程序一样），您可以使用T.replace：

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

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

我是Haskell的新手，我试图让它对像我这样的人来说更简单。

我想这可能有用。

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)