avis ma 1ere fonction: replace

[josmiley]

bonjour,

je débute avec haskell,
j'ai écrit ma 1ère fonction qui ... fonctionne.

Code :

1
2
3
4
5
6
replace :: [Char] -> [Char] -> [Char] -> [Char]
replace str substr substit
    | null str = []
    | null substr = head str : if tail str /= [] then substit ++ replace (tail str) substr substit else []
    | take (length substr) str == substr = substit ++ replace (drop (length substr) str) substr substit
    | otherwise = head str : replace (tail str) substr substit

c'est l'équivalent de str.replace() en python.

j'aimerai vos avis ...

sinon,
j'essaye

Code :

intercalate "foo" "bar"

et je m'attends à "bfooafoor" mais c'est pas le cas.
"bar" c'est pas comme une liste ?

[Ptival]

Voilà ce que j'aurais écrit pour replace :

Code :

1
2
3
4
5
6
7
8
9
10
replace :: String -> String -> String -> String
replace [] _ _          = []
replace s [] substitute = intercalate substitute (map (\x -> [x]) s)
replace (c:cs)@s pattern substitute
  | sbegin == pattern   = substitute ++ (replaceRec srest)
  | otherwise           = c : (replaceRec cs)
  where
    replaceRec s = replace s pattern substitute
    (sbegin, srest) = splitAt (length pattern) s

Ca me semble plus simple à lire que ce que tu écrivais. Notamment, je déconstruis la liste par pattern-matching, plutôt qu'avec des tests comme null str et des appels à head et tail. En général, on n'utilise pas ces fonctions comme tu le fais.

Quant à intercalate, son type est http://www.haskell.org/hoogle/?hoogle=intercalate :

Code :

intercalate :: [a] -> [[a]] -> [a]

Le deuxième argument doit être une liste d'éléments du type du premier. Aussi, tu dois transformer "bar" en ["b", "a", "r"]. C'est ce que fait le (map (\x -> [x]) s) dans mon code. J'aurais pensé qu'une telle fonction existait, mais je ne l'ai pas trouvée.

[josmiley]

ok, je comprends pour intercalate ...

et j'ai appris ce que sont @ et splitAt, bien pratique ...

Code :

1
2
3
4
5
6
7
replace :: [Char] -> [Char] -> [Char] -> [Char]
replace [] _ _   = []
replace str@(h:t) substr substit
    | null substr      = h : if t /= [] then substit ++ replace t substr substit else []
    | start  == substr = substit ++ replace end substr substit
    | otherwise        = h : replace t substr substit
    where (start,end)  = splitAt (length substr) str

merci pour les conseils; j'essaye de faire un pendu, si j'ai d'autre questions je les poserai ici.

[Yo Eight]

Il y a la fonction stripPrefix dans le module Data.List qui est pas mal

Code Haskell :

1
2
3
4
5
6
7
replace :: String -> String -> String -> String
replace _ _ [] = [] 
replace toBeReplaced substitute s@(x:xs) = 
  case stripPrefix toBeReplaced s of
    Nothing         -> x : replace toBeReplaced substitute xs
    (Just stripped) -> substitute ++ replace toBeReplaced substitute stripped