功能上用分隔符分隔字符串的最佳方法是什麼？

Question

我試圖通過1

寫在Haskell程序，將採取由逗號定界整數一串數字，將其轉換爲整數的列表，並增加每個號碼例如 "1,2,-5,-23,15" -> [2,3,-4,-22,16]

下面是生成的程序

import Data.List 

main :: IO() 
main = do 
    n <- return 1 
    putStrLn . show . map (+1) . map toInt . splitByDelimiter delimiter 
    $ getList n 

getList :: Int -> String 
getList n = foldr (++) [] . intersperse [delimiter] $ replicate n inputStr 

delimiter = ',' 

inputStr = "1,2,-5,-23,15" 

splitByDelimiter :: Char -> String -> [String] 
splitByDelimiter _ "" = [] 
splitByDelimiter delimiter list = 
    map (takeWhile (/= delimiter) . tail) 
    (filter (isPrefixOf [delimiter]) 
     (tails 
      (delimiter : list))) 

toInt :: String -> Int 
toInt = read 

對我來說，最困難的部分是一個字符串並將返回字符串

列表的功能 splitByDelimiter編程

"1,2,-5,-23,15" -> ["1","2","-5","-23","15"]

認爲它工作，我不滿意它的寫法。有很多括號，所以它看起來像Lisp。同樣的算法是有點人爲：

1. 前面加上分隔字符串的開頭",1,2,-5,-23,15"

2. 生成所有的尾巴[",1,2,-5,-23,15", "1,2,-5,-23,15", ",2,-5,-23,15", .... ]

3. 過濾器的列表，只留下與分隔符開頭的字符串[",1,2,-5,-23,15", ",2,-5,-23,15", .... ]

4. 放下第一個分隔符並採用符號，直到達到下一個分隔符["1", "2", .... ]

所以問題是：

我怎樣才能改善功能splitByDelimiter？

我可以刪除前綴和刪除分隔符並直接拆分字符串嗎？

如何重寫函數以減少括號？

可能我錯過了一些東西，並且已經有了這個功能的標準功能？

Answer 1

是不是Data.List.Split.splitOn這樣做？

Answer 2

這是一個黑客，但它，它的作品。

yourFunc str = map (+1) $ read ("[" ++ str ++ "]") 

下面是使用unfoldr非破解版：

import Data.List 
import Control.Arrow(second) 

-- break' is like break but removes the 
-- delimiter from the rest string 
break' d = second (drop 1) . break d 

split :: String -> Maybe (String,String) 
split [] = Nothing 
split xs = Just . break' (==',') $ xs 

yourFunc :: String -> [Int] 
yourFunc = map ((+1) . read) . unfoldr split 

Answer 3

這是應用HaskellElephant的回答原來的問題，有輕微的變化

 
splitByDelimiter :: Char -> String -> [String] 
splitByDelimiter = unfoldr . splitSingle 

splitSingle :: Char -> String -> Maybe (String,String) 
splitSingle _ [] = Nothing 
splitSingle delimiter xs = 
    let (ys, zs) = break (== delimiter) xs in 
    Just (ys, drop 1 zs) 

凡功能splitSingle分裂名單在第一個分隔符的兩個子串中。

例如： "1,2,-5,-23,15" -> Just ("1", "2,-5,-23,15")

Answer 4

只是爲了好玩，這裏是你如何創建一個簡單的解析器使用秒差距：

module Main where 

import Control.Applicative hiding (many) 
import Text.Parsec 
import Text.Parsec.String 

line :: Parser [Int] 
line = number `sepBy` (char ',' *> spaces) 

number = read <$> many digit 

一個優點是，它很容易地創建一個解析器是在什麼靈活它將接受：

*Main Text.Parsec Text.Parsec.Token> :load "/home/mikste/programming/Temp.hs" 
[1 of 1] Compiling Main    (/home/mikste/programming/Temp.hs, interpreted) 
Ok, modules loaded: Main. 
*Main Text.Parsec Text.Parsec.Token> parse line "" "1, 2, 3" 
Right [1,2,3] 
*Main Text.Parsec Text.Parsec.Token> parse line "" "10,2703, 5, 3" 
Right [10,2703,5,3] 
*Main Text.Parsec Text.Parsec.Token> 

Answer 5

splitBy delimiter = foldr f [[]] 
      where f c l@(x:xs) | c == delimiter = []:l 
          | otherwise = (c:x):xs 

編輯：不是由原作者，但下面是一個更多（過分？）詳細和靈活性較差的版本（具體到Char/String），以幫助澄清如何工作。使用上述版本是因爲它適用於任何使用Eq實例的類型列表。

splitBy :: Char -> String -> [String] 
splitBy _ "" = []; 
splitBy delimiterChar inputString = foldr f [""] inputString 
    where f :: Char -> [String] -> [String] 
     f currentChar allStrings@(partialString:handledStrings) 
      | currentChar == delimiterChar = "":allStrings -- start a new partial string at the head of the list of all strings 
      | otherwise = (currentChar:partialString):handledStrings -- add the current char to the partial string 

-- input:  "a,b,c" 
-- fold steps: 
-- first step: 'c' -> [""] -> ["c"] 
-- second step: ',' -> ["c"] -> ["","c"] 
-- third step: 'b' -> ["","c"] -> ["b","c"] 
-- fourth step: ',' -> ["b","c"] -> ["","b","c"] 
-- fifth step: 'a' -> ["","b","c"] -> ["a","b","c"] 

Answer 6

splitBy del str = helper del str [] 
    where 
     helper _ [] acc = let acc0 = reverse acc in [acc0] 
     helper del (x:xs) acc 
      | x==del = let acc0 = reverse acc in acc0 : helper del xs [] 
      | otherwise = let acc0 = x : acc  in helper del xs acc0 

Answer 7

此代碼工作正常 用途： - 分裂 「你的字符串」[]與任何分隔符來替換 ''

split [] t = [t] 
split (a:l) t = if a==',' then (t:split l []) else split l (t++[a]) 

Answer 8

import qualified Text.Regex as RegExp 

myRegexSplit :: String -> String -> [String] 
myRegexSplit regExp theString = 
    let result = RegExp.splitRegex (RegExp.mkRegex regExp) theString 
    in filter (not . null) result 

-- using regex has the advantage of making it easy to use a regular 
-- expression instead of only normal strings as delimiters. 

-- the splitRegex function tends to return an array with an empty string 
-- as the last element. So the filter takes it out 

-- how to use in ghci to split a sentence 
let timeParts = myRegexSplit " " "I love ponies a lot"