如何在Haskell中分割字符串？

Question

有没有一种标准的方式来分割Haskell中的字符串？

lines和words在分隔空间或换行符方面效果很好，但肯定有一个标准的方式来分隔逗号？我无法在Hoogle上找到它？

具体而言，我正在寻找的东西在那里split "," "my,comma,separated,list"回报["my","comma","separated","list"]

感谢。

Answer 1

这个包叫做split。

cabal install split 

使用方法如下：

ghci> import Data.List.Split 
ghci> splitOn "," "my,comma,separated,list" 
["my","comma","separated","list"] 

它配备了很多其他功能上匹配的分隔符或有几个分隔符分割。

Answer 2

试试这个：

import Data.List (unfoldr) 

separateBy :: Eq a => a -> [a] -> [[a]] 
separateBy chr = unfoldr sep where 
    sep [] = Nothing 
    sep l = Just . fmap (drop 1) . break (== chr) $ l 

，只对单个字符，但应该很容易扩展。

Answer 3

在模块Text.Regex（Haskell的平台的一部分），有一个功能：

splitRegex :: Regex -> String -> [String] 

其将基于正则表达式的字符串。该API可在Hackage找到。

Answer 4

请记住，您可以查看Prelude函数的定义！

http://www.haskell.org/onlinereport/standard-prelude.html

看那里，words的定义是，

words :: String -> [String] 
words s = case dropWhile Char.isSpace s of 
         "" -> [] 
         s' -> w : words s'' 
          where (w, s'') = break Char.isSpace s' 

所以，改变它，需要一个谓词的函数：

wordsWhen  :: (Char -> Bool) -> String -> [String] 
wordsWhen p s = case dropWhile p s of 
         "" -> [] 
         s' -> w : wordsWhen p s'' 
          where (w, s'') = break p s' 

然后与任何断言叫它你要！

main = print $ wordsWhen (==',') "break,this,string,at,commas" 

Answer 5

我不知道如何添加注释到史蒂夫的答案，但我想推荐
    GHC libraries documentation，
并在那里特别是
    Sublist functions in Data.List

作为参考，这要比阅读普通的Haskell报告好得多。一般来说，一个关于何时创建一个新的子列表以供应的规则的折叠也应该解决它。

Answer 6

我开始学习Haskell昨天，所以纠正我，如果我错了，但：

split :: Eq a => a -> [a] -> [[a]] 
split x y = func x y [[]] 
    where 
     func x [] z = reverse $ map (reverse) z 
     func x (y:ys) (z:zs) = if y==x then 
      func x ys ([]:(z:zs)) 
     else 
      func x ys ((y:z):zs) 

给出：

*Main> split ' ' "this is a test" 
["this","is","a","test"] 

或者你想

*Main> splitWithStr " and " "this and is and a and test" 
["this","is","a","test"] 

这将是：

splitWithStr :: Eq a => [a] -> [a] -> [[a]] 
splitWithStr x y = func x y [[]] 
    where 
     func x [] z = reverse $ map (reverse) z 
     func x (y:ys) (z:zs) = if (take (length x) (y:ys)) == x then 
      func x (drop (length x) (y:ys)) ([]:(z:zs)) 
     else 
      func x ys ((y:z):zs) 

Answer 7

如果使用Data.Text，有splitOn：

http://hackage.haskell.org/packages/archive/text/0.11.2.0/doc/html/Data-Text.html#v:splitOn

这是建于哈斯克尔平台。

因此，例如：

import qualified Data.Text as T 
main = print $ T.splitOn (T.pack " ") (T.pack "this is a test") 

或：

{-# LANGUAGE OverloadedStrings #-} 

import qualified Data.Text as T 
main = print $ T.splitOn " " "this is a test" 

Answer 8

使用Data.List.Split，它采用split：

[me@localhost]$ ghci 
Prelude> import Data.List.Split 
Prelude Data.List.Split> let l = splitOn "," "1,2,3,4" 
Prelude Data.List.Split> :t l 
l :: [[Char]] 
Prelude Data.List.Split> l 
["1","2","3","4"] 
Prelude Data.List.Split> let { convert :: [String] -> [Integer]; convert = map read } 
Prelude Data.List.Split> let l2 = convert l 
Prelude Data.List.Split> :t l2 
l2 :: [Integer] 
Prelude Data.List.Split> l2 
[1,2,3,4] 

Answer 9

split :: Eq a => a -> [a] -> [[a]] 
split d [] = [] 
split d s = x : split d (drop 1 y) where (x,y) = span (/= d) s 

例如

split ';' "a;bb;ccc;;d" 
> ["a","bb","ccc","","d"] 

单个尾随分隔符将被丢弃：

split ';' "a;bb;ccc;;d;" 
> ["a","bb","ccc","","d"] 

Answer 10

除了给出答案的高效和预先内建的功能，我会加上我自己这只是我的Haskell的剧目的一部分功能我写学习语言上我自己的时间：

-- Correct but inefficient implementation 
wordsBy :: String -> Char -> [String] 
wordsBy s c = reverse (go s []) where 
    go s' ws = case (dropWhile (\c' -> c' == c) s') of 
     "" -> ws 
     rem -> go ((dropWhile (\c' -> c' /= c) rem)) ((takeWhile (\c' -> c' /= c) rem) : ws) 

-- Breaks up by predicate function to allow for more complex conditions (\c -> c == ',' || c == ';') 
wordsByF :: String -> (Char -> Bool) -> [String] 
wordsByF s f = reverse (go s []) where 
    go s' ws = case ((dropWhile (\c' -> f c')) s') of 
     "" -> ws 
     rem -> go ((dropWhile (\c' -> (f c') == False)) rem) (((takeWhile (\c' -> (f c') == False)) rem) : ws) 

的解决方案是至少尾递归，使他们不会产生一个堆栈溢出。

Answer 11

例如，在ghci的：

> import qualified Text.Regex as R 
> R.splitRegex (R.mkRegex "x") "2x3x777" 
> ["2","3","777"]