Come dividere una stringa in Haskell?

Esiste un modo standard per dividere una stringa in Haskell?

linese wordsfunziona alla grande partendo da uno spazio o da una nuova riga, ma sicuramente esiste un modo standard per dividere una virgola?

Non sono riuscito a trovarlo su Hoogle.

Per essere precisi, sto cercando qualcosa in cui split "," "my,comma,separated,list"ritorni ["my","comma","separated","list"].

Esiste un pacchetto per questo chiamato split .

cabal install split

Usalo in questo modo:

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

Viene fornito con molte altre funzioni per dividere i delimitatori corrispondenti o avere diversi delimitatori.

Ricorda che puoi cercare la definizione delle funzioni di Prelude!

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

Guardando lì, la definizione di wordsè,

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

Quindi, cambiarlo per una funzione che accetta un predicato:

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

Quindi chiamalo con qualunque predicato tu voglia!

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

Se usi Data.Text, c'è splitOn:

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

Questo è integrato nella piattaforma Haskell.

Quindi per esempio:

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

o:

{-# LANGUAGE OverloadedStrings #-}

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

Nel modulo Text.Regex (parte della piattaforma Haskell), c'è una funzione:

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

che divide una stringa in base a un'espressione regolare. L'API è disponibile su Hackage .

Usa Data.List.Split, che utilizza 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]

Prova questo:

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

Funziona solo per un singolo carattere, ma dovrebbe essere facilmente estensibile.

Senza importare nulla una sostituzione diretta di un carattere per uno spazio, il separatore di destinazione per wordsè uno spazio. Qualcosa di simile a:

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

o

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

Puoi trasformarlo in una funzione con parametri. Puoi eliminare il parametro carattere-per-abbinare il mio abbinamento molti, come in:

 [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

Per esempio

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

Verrà eliminato un singolo delimitatore finale:

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

Ho iniziato a studiare Haskell ieri, quindi correggimi se sbaglio ma:

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)

dà:

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

o forse volevi

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

quale sarebbe:

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)

Non so come aggiungere un commento alla risposta di Steve, ma vorrei raccomandare la
  documentazione delle librerie GHC ,
e in particolare le
  funzioni di Sublist in Data.List

Il che è molto meglio come riferimento, piuttosto che leggere il semplice rapporto Haskell.

In genere, anche una piega con una regola su quando creare un nuovo elenco secondario da alimentare, dovrebbe risolverlo.

Oltre alle funzioni efficienti e predefinite fornite nelle risposte, aggiungerò le mie che sono semplicemente parte del mio repertorio di funzioni di Haskell che stavo scrivendo per imparare la lingua nel mio tempo:

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

Le soluzioni sono almeno ricorsive alla coda, quindi non incorreranno in un overflow dello stack.

Esempio nel ghci:

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

Lo trovo più semplice da capire:

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