StringUtils by Luca Ciciriello 2011-2016
> module StringUtils where
> import Data.Char
> import Data.List
Replace a single char in the specified position
> replace :: Int -> String -> String -> String
> replace _ _ "" = ""
> replace n ch str = (take n str) ++ ch ++ (drop (n+1) str)
Replace a single char with a new one when occurs in a string
> replace_all :: String -> String -> String -> String
> replace_all old new str | p == (-1) = s
>                         | otherwise = (take p str) ++  new ++ (replace_all old new s)
>                         where p = find_first old str
>                               s = drop (p+1) str
Replace a substring wit a new one when occurs in a string
> replace_all_str :: String -> String -> String -> String
> replace_all_str old new str | p == (-1) = s
>                             | otherwise = (take p str) ++  new ++ (drop (len - 1) (replace_all_str old new s))
>                             where p = find_str old str
>                                   s = drop (p+1) str
>                                   len | length old == 0 = 0
>                                       | otherwise = length old
Restituisce la posizione della prima occorrenza della stringa specificata in una stringa
> find_first :: (Eq a) => [a] -> [a] -> Int
> find_first _ [] = -1
> find_first [] _ = -1 
> find_first (x:ys) xs | (x `elem` xs) == False = -1 
>                      | otherwise = head (positions x xs) 
Replace first occurrence of a substring in a string starting from a specified position
> find_fst_from :: (Eq a) => [a] -> [a] -> Int -> Int
> find_fst_from _ [] _ = -1
> find_fst_from [] _ _ = -1 
> find_fst_from x xs off  | (x `isIn` str) == False = -1
>                         | otherwise = (find_first x str) + off
>                         where str = (drop off xs)
As find_first but using String type
> find_str :: String -> String -> Int
> find_str "" _ = -1
> find_str _ [] = -1
> find_str sub xs | null lst = -1
>                 | otherwise = head lst
>                 where lst = matching_lst sub xs (fst_pos_lst sub xs)
As find_fst_from but using String type
> find_str_from :: String -> String -> Int -> Int
> find_str_from _ [] _ = -1
> find_str_from [] _ _ = -1 
> find_str_from sub xs off | (pos == -1) = -1
>                          | otherwise = pos + off
>                          where str = (drop off xs)
>                                pos = find_str sub str
Returns a substring of a string starting from a specified position and for a pecified num of char
> substr :: Int -> Int -> String -> String
> substr _ _ "" = ""
> substr pos num str = take num (drop pos str)
Returns the char in a specified position in a string
> get_ch_at :: String -> Int -> Char
> get_ch_at [] _ = '_'
> get_ch_at str n = str !! n
Returns the position of the first occurrence of a specified char in a string
> positions :: (Eq a) => a -> [a] -> [Int]
> positions _ [] = []
> positions x xs = [i | (x', i) <- zip xs [0 .. n], x == x']
>                where n = length xs - 1
str_positions :: String -> String -> [Int] str_positions _ "" = [] str_positions x xs | pos == -1 = [] | otherwise = (find_str x xs) : [find_str x sss] where sss = drop (pos+1) xs pos = find_str x xs Returns the positions list of all occurrence of a substring in a string
> indicesOfSubStr :: String -> String -> [Int]
> indicesOfSubStr []  _   = []
> indicesOfSubStr sub str = filter (\i -> sub `isPrefixOf` drop i str) $ head sub `elemIndices` str
Cunts the occurences of a specified char in a string
> count :: (Eq a) => a -> [a] -> Int
> count _ [] = 0
> count x xs = length $ positions x xs
Checks if a specified substring is present in a string
> isIn :: (Eq a) => [a] -> [a] -> Bool
> isIn (x:xs) str = x `elem` str
Removes the char in a specified position in a string
> delete_at :: Int -> String -> String
> delete_at 0 xs = xs
> delete_at _ "" = ""
> delete_at pos xs = (take pos xs) ++ (drop (pos+1) xs)
Removes all the occurrences of a char in a string
> delete_all :: String -> String -> String
> delete_all _ "" = ""
> delete_all "" xs = xs
> delete_all el xs = replace_all el "" xs
Inserts a substring in a specified position in a string
> insert_at :: Int -> String -> String -> String
> insert_at _ "" xs = xs
> insert_at _ el "" = el
> insert_at pos el xs | (pos > (length xs) || pos < 0) == True = xs
>                     | otherwise = (take pos xs) ++ el ++ (drop pos xs)
Transform all lowercase chars in a string in uppercase chars
> to_upper :: String -> String
> to_upper "" = ""
> to_upper xs = map toUpper xs
Transform all uppercase chars in a string in lowercase chars
> to_lower :: String -> String
> to_lower "" = ""
> to_lower xs = map toLower xs
Returns a positions list of a specified char in a string
> fst_pos_lst :: String -> String -> [Int]
> fst_pos_lst sub xs = positions (sub `get_ch_at` 0) xs
Just for internal use
> matching_lst :: String -> String -> [Int] -> [Int]
> matching_lst sub xs ps = [p | p <- ps, mtc p]
>                       where mtc p = (sub == (substr p (length sub) xs))
Removes starting spaces in a string
> trim_left :: String -> String
> trim_left "" = ""
> trim_left (x:xs) | (x /= ' ') = x : xs
>                  | otherwise  = trim_left xs
Removes starting spaces, tabs, and newlines in a string
> trim_left_complete :: String -> String
> trim_left_complete "" = ""
> trim_left_complete (x:xs) | (x /= ' ' && x /= '\t' && x /= '\r' && x /= '\n') = x : xs
>                           | otherwise = trim_left_complete xs
Removes ending spaces in a string
> trim_right :: String -> String
> trim_right str = (reverse . trim_left . reverse) str
Removes ending spaces, tabs, and newlines in a string
> trim_right_complete :: String -> String
> trim_right_complete str = (reverse . trim_left_complete . reverse) str
Removes all starting and ending spaces in a string
> trim :: String -> String
> trim str = (trim_right . trim_left) str
Removes all starting and ending spaces, tabs and newlines in a string
> trim_complete :: String -> String
> trim_complete str = (trim_right_complete . trim_left_complete) str