Comment diviser une chaîne de caractères en Haskell ?

Question

Existe-t-il un moyen standard de diviser une chaîne de caractères en Haskell ?

lines y words fonctionnent très bien lorsqu'ils sont séparés par un espace ou une nouvelle ligne, mais il existe sûrement un moyen standard de les séparer par une virgule ?

Je ne l'ai pas trouvé sur Hoogle.

Pour être plus précis, je cherche quelque chose où split "," "my,comma,separated,list" renvoie à ["my","comma","separated","list"] .

Answer 1

N'oubliez pas que vous pouvez consulter la définition des fonctions Prelude !

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

En regardant là, la définition de words est,

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

Donc, changez-le pour une fonction qui prend un prédicat :

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

Ensuite, appelez-le avec le prédicat que vous voulez !

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

Answer 2

Il existe un paquet pour cela appelé divisé .

cabal install split

Utilisez-le comme ça :

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

Il est doté de nombreuses autres fonctions permettant de diviser sur des délimiteurs correspondants ou sur plusieurs délimiteurs.

Answer 3

Si vous utilisez Data.Text, il y a splitOn :

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

Il est construit dans la plateforme Haskell.

Ainsi, par exemple :

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"

Answer 4

Dans le module Text.Regex (qui fait partie de la plate-forme Haskell), il existe une fonction :

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

qui divise une chaîne de caractères en fonction d'une expression régulière. L'API se trouve à l'adresse suivante Hackage .

Answer 5

Essaie celle-là :

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

Ne fonctionne que pour un seul personnage, mais devrait être facilement extensible.