Como dividir uma string em Haskell?

Existe uma maneira padrão de dividir uma string em Haskell?

linese wordsfunciona muito bem ao dividir em um espaço ou nova linha, mas certamente existe uma maneira padrão de dividir em uma vírgula?

Não encontrei no Hoogle.

Para ser específico, estou procurando algo em que split "," "my,comma,separated,list"retorne ["my","comma","separated","list"].

Há um pacote para esse chamado split .

cabal install split

Use-o assim:

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

Ele vem com muitas outras funções para dividir em delimitadores correspondentes ou ter vários delimitadores.

Lembre-se de que você pode procurar a definição de funções do Prelude!

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

Olhando para lá, a definição de wordsé,

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

Portanto, altere-o para uma função que aceita um predicado:

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

Em seguida, chame-o com o predicado que você quiser!

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

Se você usar Data.Text, haverá splitOn:

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

Isso é construído na plataforma Haskell.

Então, por exemplo:

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

ou:

{-# LANGUAGE OverloadedStrings #-}

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

No módulo Text.Regex (parte da plataforma Haskell), existe uma função:

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

que divide uma string com base em uma expressão regular. A API pode ser encontrada em Hackage .

Use Data.List.Split, que usa 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]

Tente este:

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

Funciona apenas para um único caractere, mas deve ser facilmente extensível.

Sem importar nada, uma substituição direta de um caractere por um espaço, o separador de destino para wordsé um espaço. Algo como:

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

ou

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

Você pode transformar isso em uma função com parâmetros. Você pode eliminar o parâmetro caractere para corresponder à minha correspondência, como em:

 [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

Por exemplo

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

Um único delimitador à direita será eliminado:

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

Comecei a aprender Haskell ontem, então me corrija se estiver errado, mas:

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"]

ou talvez você quisesse

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

qual seria:

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)

Eu não sei como adicionar um comentário sobre a resposta de Steve, mas eu gostaria de recomendar a
  documentação GHC bibliotecas ,
e em lá especificamente as
  funções de sub-lista em Data.List

O que é muito melhor como referência do que apenas ler o relatório simples de Haskell.

Geralmente, uma dobra com uma regra sobre quando criar uma nova sublist para alimentar, também deve resolvê-la.

Além das funções eficientes e pré-criadas fornecidas nas respostas, adicionarei as minhas, que são simplesmente parte do meu repertório de funções Haskell que eu estava escrevendo para aprender o idioma em meu próprio 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)

As soluções são pelo menos recursivas de cauda, ​​para que não ocorram um estouro de pilha.

Exemplo no ghci:

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

Acho isso mais simples de entender:

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