Haskell String ersetzen

Question

Wie ersetze ich ein Zeichen durch mehrere Zeichen in einer Zeichenfolge. Ich kann mit unten, um ein Zeichen durch ein anderes Zeichen ersetzt werden:

replaceO [] = [] 
    replaceO (x:xs) = 
    if x == '(' 
    then '\n' : replaceO xs 
    else x : replaceO xs 

Aber ich mag ersetzen '(' mit "\ n \ t \ t", nicht nur '\ n'

-. -------- UPDATE -------------- Basierend auf der Antwort unten, kann ich machen, dass eine Funktion, die einen String und gibt eine Zeichenfolge wie folgt akzeptiert:

ReplaceFun str :: String -> String 
ReplaceFun str = do 
    concatMap (\str -> if str == '.' then "foo" else [str]) 

Das funktioniert nicht, kann jemand auf meinen Fehler hinweisen? Ich bin sehr neu in Haskell.

Hier

ist, was ich für verschachtelte Einbuchtung haben:

replaceO (x:xs) n l = 
    if x == '(' 
    then "\n" ++ (showTabs n "-") ++ replaceO xs (n + 1) 'l' 
    else 
     if x == ')' 
     then "\n" ++ (showTabs n "-") ++ replaceO xs (n - 1) 'l' 
     else x : replaceO xs n 'l' 

Answer 1

Gerade concatMap

Prelude> concatMap (\x -> if x == '.' then "foo" else [x]) "example..." 
"examplefoofoofoo" 

Answer 2

Erweiterung Ihres Beispiel verwenden, können Sie ersetzen "\ n \ t \ t" für "(" von nur mehrere Dinge auf das Ergebnis des rekursiven Aufruf voranstellen

replace1 [] = [] 
replace1 (x:xs) = 
    if x == '(' 
    then '\n' : '\t' : '\t' : replace1 xs 
    else x : replace1 xs 

natürlich ist dies äquivalent zur Verwendung von "\n\t\t" ++

replace2 [] = [] 
replace2 (x:xs) = 
    if x == '(' 
    then "\n\t\t" ++ replace2 xs 
    else x : replace2 xs 

wenn wir feststellen, dass x : äquivalent zu [x] ++

replace3 [] = [] 
replace3 (x:xs) = 
    if x == '(' 
    then "\n\t\t" ++ replace3 xs 
    else [x] ++ replace3 xs 

dann können wir

replace4 [] = [] 
replace4 (x:xs) = (if x == '(' then "\n\t\t" else [x]) ++ replace4 xs 

dann die wiederholte rekursiven Aufruf ausklammern für Klarheit, könnten wir die if Aussage herauszufiltern in eine Funktion:

replace5 [] = [] 
replace5 (x:xs) = f x ++ replace5 xs 
    where f x = if x == '(' 
       then "\n\t\t" 
       else [x] 

dann könnten wir unseren Code reorganisieren - anstatt abwechselnd f zu jedem x und es um unsere Ergebnisse der Anwendung anhängt, könnten wir f auf alle xs anwenden und dann alle Ergebnisse verketten:

replace6 xs = concat $ map f xs 
    where f x = if x == '(' 
       then "\n\t\t" 
       else [x] 

Aber concat $ map f xs so oft verwendet wird, dass es einen anderen Namen hat:

replace7 xs = concatMap f xs 
    where f x = if x == '(' 
       then "\n\t\t" 
       else [x] 

Eigentlich hat es ein anderes auch, weil [] eine Monade ist:

replace8 xs = xs >>= f 
    where f x = if x == '(' 
       then "\n\t\t" 
       else [x] 

Aber wenn wir das tun, können wir auch voll Monade gehen:

replace9 xs = do 
    x <- xs 
    if x == '(' 
    then "\n\t\t" 
    else [x] 

Aber ich würde wahrscheinlich nur bei replace7 stoppen, persönlich.