Haskell'de bir dize nasıl bölünür?

Haskell'de bir dizeyi bölmenin standart bir yolu var mı?

linesve wordsbir boşlukta veya satırsonunda bölünmekten harika çalışıyor, ama kesinlikle bir virgül üzerinde bölünmenin standart bir yolu var mı?

Hoogle'da bulamadım.

Spesifik olarak, split "," "my,comma,separated,list"geri dönecek bir şey arıyorum ["my","comma","separated","list"].

Bunun için split denilen bir paket var .

cabal install split

Şöyle kullanın:

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

Eşleşen sınırlayıcılara bölmek veya birkaç sınırlayıcıya sahip olmak için birçok başka işlevle birlikte gelir.

Prelude fonksiyonlarının tanımına bakabileceğinizi unutmayın!

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

Oraya bakıldığında words,

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

Bu nedenle, yüklem alan bir işlev için değiştirin:

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

O zaman istediğiniz yüklemle çağırın!

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

Data.Text kullanıyorsanız splitOn var:

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

Bu Haskell Platformunda oluşturulmuştur.

Örneğin:

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

veya:

{-# LANGUAGE OverloadedStrings #-}

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

Text.Regex modülünde (Haskell Platformunun bir parçası), bir işlev vardır:

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

normal bir ifadeye dayalı olarak bir dize böler. API, Hackage'da bulunabilir .

Kullanım Data.List.Splitkullanır 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]

Bunu dene:

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

Sadece tek bir karakter için çalışır, ancak kolayca genişletilebilir olmalıdır.

Hiçbir şey bir alan için bir karakterin doğrudan yerine konulmadan, hedef ayırıcı wordsbir boşluktur. Gibi bir şey:

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

veya

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

Bunu parametrelerle bir fonksiyona dönüştürebilirsiniz. Eşleştiğim birçok karakterle eşleşecek karakter karakterini şu şekilde kaldırabilirsiniz :

 [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

Örneğin

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

Tek bir izleyen sınırlayıcı bırakılır:

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

Dün Haskell öğrenmeye başladım, eğer yanılıyorsam beni düzelt ama:

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)

verir:

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

ya da belki istedin

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

hangisi olurdu:

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)

Steve'in cevap üzerine açıklama eklemek için nasıl bilmiyorum, ama ben tavsiye etmek istiyorum
  GHC kütüphaneleri belgelerine ,
ve orada özel olarak
  Data.List içinde subList fonksiyonlar

Bir referans olarak, sadece düz Haskell raporunu okumaktan daha iyidir.

Genel olarak, beslenecek yeni alt listenin ne zaman oluşturulacağına dair bir kuralı olan bir katlama da onu çözmelidir.

Cevaplarda verilen verimli ve önceden oluşturulmuş fonksiyonlara ek olarak, kendi zamanımda dili öğrenmek için yazdığım Haskell fonksiyonlarının repertuarının bir parçası olan kendim ekleyeceğim:

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

Çözümler en azından kuyruk yinelemelidir, bu nedenle yığın taşmasına neden olmazlar.

Ghci'de örnek:

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

Bunu anlamak daha basit buluyorum:

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