Bagaimana cara membagi string di Haskell?

Apakah ada cara standar untuk membagi string di Haskell?

linesdan wordsbekerja dengan baik dari pemisahan pada ruang atau baris baru, tetapi pasti ada cara standar untuk membagi pada koma?

Saya tidak dapat menemukannya di Hoogle.

Untuk lebih spesifik, saya mencari sesuatu di mana split "," "my,comma,separated,list"kembali ["my","comma","separated","list"].

Ada paket untuk split yang disebut ini .

cabal install split

Gunakan seperti ini:

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

Muncul dengan banyak fungsi lain untuk membelah pada pembatas yang cocok atau memiliki beberapa pembatas.

Ingatlah bahwa Anda dapat mencari definisi fungsi Prelude!

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

Melihat di sana, definisi dari wordsadalah,

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

Jadi, ubah untuk fungsi yang mengambil predikat:

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

Kemudian menyebutnya dengan predikat apa pun yang Anda inginkan!

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

Jika Anda menggunakan Data.Text, ada splitOn:

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

Ini dibangun di Platform Haskell.

Jadi misalnya:

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

atau:

{-# LANGUAGE OverloadedStrings #-}

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

Dalam modul Text.Regex (bagian dari Platform Haskell), ada fungsi:

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

yang membagi string berdasarkan pada ekspresi reguler. API dapat ditemukan di Hackage .

Gunakan Data.List.Split, yang menggunakan 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]

Coba yang ini:

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

Hanya bekerja untuk satu karakter, tetapi harus mudah diperpanjang.

Tanpa mengimpor apa pun pengganti langsung dari satu karakter untuk spasi, pemisah target wordsadalah spasi. Sesuatu seperti:

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

atau

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

Anda dapat menjadikan ini sebagai fungsi dengan parameter. Anda dapat menghilangkan parameter -to-match parameter saya yang cocok banyak, seperti di:

 [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

Misalnya

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

Pembatas trailing tunggal akan dijatuhkan:

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

Saya mulai belajar Haskell kemarin, jadi koreksi saya jika saya salah tetapi:

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)

memberi:

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

atau mungkin Anda inginkan

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

yang akan menjadi:

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)

Saya tidak tahu bagaimana cara menambahkan komentar pada jawaban Steve, tetapi saya ingin merekomendasikan
  dokumentasi perpustakaan GHC ,
dan di sana secara khusus
  fungsi Sublist di Data.List

Yang jauh lebih baik sebagai referensi, daripada hanya membaca laporan Haskell biasa.

Secara umum, lipatan dengan aturan kapan membuat sublist baru untuk diumpankan, harus menyelesaikannya juga.

Selain fungsi efisien dan pra-dibangun yang diberikan dalam jawaban saya akan menambahkan sendiri yang hanya bagian dari perbendaharaan fungsi Haskell yang saya tulis untuk mempelajari bahasa pada waktu saya sendiri:

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

Solusi setidaknya rekursif ekor sehingga mereka tidak akan menyebabkan stack overflow.

Contoh dalam ghci:

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

Saya menemukan ini lebih mudah untuk dipahami:

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