Làm thế nào để tách một chuỗi trong Haskell?

Có một cách tiêu chuẩn để phân chia một chuỗi trong Haskell?

linesvà wordslàm việc tuyệt vời từ việc phân tách trên một không gian hoặc dòng mới, nhưng chắc chắn có một cách tiêu chuẩn để phân chia trên dấu phẩy?

Tôi không thể tìm thấy nó trên Hoogle.

Để cụ thể, tôi đang tìm kiếm một cái gì đó split "," "my,comma,separated,list"trở lại ["my","comma","separated","list"].

Có một gói cho cái này được gọi là chia .

cabal install split

Sử dụng nó như thế này:

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

Nó đi kèm với rất nhiều chức năng khác để phân tách trên các dấu phân cách phù hợp hoặc có một số dấu phân cách.

Hãy nhớ rằng bạn có thể tra cứu định nghĩa của các chức năng Prelude!

http://www.haskell.org/onlinereport/st Chuẩn-prelude.html

Nhìn vào đó, định nghĩa wordslà,

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

Vì vậy, thay đổi nó cho một hàm có một vị ngữ:

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

Sau đó gọi nó với bất kỳ vị ngữ nào bạn muốn!

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

Nếu bạn sử dụng Data.Text, có splitOn:

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

Điều này được xây dựng trong Nền tảng Haskell.

Ví dụ:

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

hoặc là:

{-# LANGUAGE OverloadedStrings #-}

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

Trong mô-đun Text.Regex (một phần của Nền tảng Haskell), có một chức năng:

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

mà tách một chuỗi dựa trên một biểu thức thông thường. API có thể được tìm thấy tại Hackage .

Sử dụng Data.List.Split, trong đó sử dụng 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]

Hãy thử cái này:

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

Chỉ hoạt động cho một char duy nhất, nhưng nên dễ dàng mở rộng.

Không nhập bất cứ thứ gì thay thế thẳng một ký tự cho một khoảng trắng, dấu phân cách đích wordslà một khoảng trắng. Cái gì đó như:

words [if c == ',' then ' ' else c|c <- "my,comma,separated,list"]

hoặc là

words let f ',' = ' '; f c = c in map f "my,comma,separated,list"

Bạn có thể biến điều này thành một hàm với các tham số. Bạn có thể loại bỏ nhiều tham số khớp với ký tự của tôi, như trong:

 [if elem c ";,.:-+@!$#?" then ' ' else c|c <-"my,comma;separated!list"]

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

Ví dụ

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

Một dấu phân cách duy nhất sẽ bị loại bỏ:

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

Tôi đã bắt đầu học Haskell ngày hôm qua, vì vậy hãy sửa tôi nếu tôi sai nhưng:

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)

cho:

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

hoặc có thể bạn muốn

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

đó sẽ là:

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)

Tôi không biết làm thế nào để thêm một bình luận lên câu trả lời của Steve, nhưng tôi muốn giới thiệu các
  tài liệu GHC thư viện ,
và trong đó đặc biệt là
  chức năng sublist trong Data.List

Đó là một tài liệu tham khảo tốt hơn nhiều so với việc chỉ đọc báo cáo Haskell đơn giản.

Nói chung, một nếp gấp với quy tắc về thời điểm tạo một danh sách con mới để cung cấp, cũng nên giải quyết nó.

Ngoài các chức năng được xây dựng sẵn và hiệu quả được đưa ra trong các câu trả lời, tôi sẽ thêm chức năng của riêng mình, đây đơn giản là một phần trong tài năng của tôi về các chức năng Haskell mà tôi đã viết để học ngôn ngữ theo thời gian của riêng tôi:

-- 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)

Các giải pháp ít nhất là đệ quy đuôi để chúng không bị tràn ngăn xếp.

Ví dụ trong ghci:

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

Tôi thấy điều này đơn giản hơn để hiểu:

split :: Char -> String -> [String]
split c xs = case break (==c) xs of 
  (ls, "") -> [ls]
  (ls, x:rs) -> ls : split c rs