Le traitement de chaîne en Haskell

Je suis très nouveau à Haskell et suis en train d'essayer de résoudre un problème qui nécessite une certaine chaîne de l'analyse. Ma Chaîne d'entrée contient une liste délimitée par des virgules de mots entre guillemets. Je veux analyser cette unique chaîne de caractères en une liste des mots comme des Chaînes de caractères. Où dois-je commencer à apprendre à propos de l'analyse telle une Chaîne de caractères? Est-il un partuclar module et/ou les fonctions qui leur seront utiles?

p.s. Ne postez pas de solution complète. Je suis juste à la demande d'un pointeur vers un point de départ pour que je puisse apprendre comment le faire.

split serait sans doute utile. Ou vous pouvez utiliser réel des analyseurs de comme parsec.
Il semble que les mots sont séparés par des virgules et citations?
Les mots sont entourés par des guillemets et délimité par des virgules.

OriginalL'auteur Code-Apprentice | 2012-06-26

  1. 5

    Depuis Strings sont simplement des listes de Chars en Haskell, Les données.Liste serait un bon endroit pour commencer à chercher (dans l'intérêt de l'apprentissage Haskell).

    Pour les cas plus complexes (où les virgules peuvent être imbriquées à l'intérieur des guillemets et doit être ignorée, par exemple), parsec (comme Daniel l'a mentionné) serait une meilleure solution.

    Aussi, si vous êtes à la recherche pour analyser CSVs vous pouvez essayer Texte.CSV, bien que je n'ai pas essayé, donc je ne peux pas dire combien utiles il sera.

    OriginalL'auteur Adam Wagner

  2. 6

    Le plus puissant de la solution est un analyseur combinator. Haskell a plusieurs de ces, mais le premier qui me viennent à l'esprit sont:

    • parsec: un très bon usage général l'analyse de la bibliothèque
    • attoparsec: une version plus rapide de parsec, qui sacrifie la qualité des messages d'erreur et d'autres fonctionnalités pour plus de rapidité
    • uu-parsinglib: un outil très puissant d'analyse de la bibliothèque

    Le gros avantage de l'analyseur combinators est qu'il est très facile de définir les analyseurs utilisant do notation (ou Applicative style, si vous préférez).

    Si vous voulez juste quelques simple et rapide de la chaîne de fonctionnalités de manipulation, puis consulter le text bibliothèque (pour la haute performance de l'octet codé de chaînes de caractères), ou Data.List (pour l'ordinaire à la liste de chaînes codées), qui fournissent les fonctions nécessaires pour manipuler des chaînes de caractères.

    Quand j'étais noob, je ne pouvais pas faire les chefs, ni les queues de uu parsinglib. Je n'ai pas essayé depuis, mais je ne le qualifierais pas exactement sympathique.

    OriginalL'auteur Gabriel Gonzalez

  3. 6

    J'ai finalement décidé de rouler ma propre analyse des fonctions, puisque c'est une situation simple. J'ai appris beaucoup de choses sur Haskell depuis que j'ai posté cette question et veulent documenter ma solution ici:

    split :: Char -> String -> [String]
split _ "" = []
split c s = firstWord : (split c rest)
    where firstWord = takeWhile (/=c) s
          rest = drop (length firstWord + 1) s

removeChar :: Char -> String -> String
removeChar _ [] = []
removeChar ch (c:cs)
    | c == ch   = removeChar ch cs
    | otherwise = c:(removeChar ch cs)

main = do
    handle <- openFile "input/names.txt" ReadMode
    contents <- hGetContents handle
    let names = sort (map (removeChar '"') (split ',' contents))
    print names
    hClose handle

    OriginalL'auteur Code-Apprentice

  4. 3

    Voici une particulièrement culotté façon de procéder:

    parseCommaSepQuotedWords :: String -> [String]
parseCommaSepQuotedWords s = read ("[" ++ s ++ "]")

    Cela pourrait fonctionner, mais il est très fragile et un peu niais. Essentiellement, vous utilisez le fait que le Haskell manière d'écrire des listes de chaînes presque coïncide avec votre façon, et donc le haut- Read instance est presque la chose que vous voulez. Vous pouvez utiliser reads pour le meilleur rapport d'erreurs, mais en réalité, vous voulez probablement faire quelque chose d'autre entièrement.

    En général, parsec est vraiment la peine de prendre un coup d'oeil à l' - c'est une joie à utiliser, et l'une des choses qui, à l'origine m'a vraiment excité à propos de Haskell. Mais si vous voulez une solution endogène, j'écris souvent des choses simples à l'aide de case déclarations sur le résultat de span et break. Supposons que vous êtes à la recherche pour le prochain point-virgule dans l'entrée. Puis break (== ';') inp sera de retour (before, after), où:

    • before est le contenu de inp jusqu'à (et non compris) le premier point-virgule (ou si il n'y a aucun)
    • after est le reste de la chaîne:
      • si after n'est pas vide, le premier élément est un point-virgule
      • peu importe quoi d'autre qui se passe, before ++ after == inp

    Donc à analyser une liste de déclarations séparées par des points-virgules, je pourrais faire ceci:

    parseStmts :: String -> Maybe [Stmt]
parseStmts inp = case break (== ';') inp of
  (before, _ : after) -> -- ...
    -- ^ before is the first statement
    --     ^ ignore the semicolon
    --           ^ after is the rest of the string
  (_, []) -> -- inp doesn't contain any semicolons

    OriginalL'auteur Ben Millwood

  5. 1

    Dans l'intérêt d'avoir une réponse complète pour ceux qui arrive sur cette question, Les données.Texte a quelques bonnes fonctions ainsi.

    OriginalL'auteur John F. Miller

  6. 1

    Utilisation parsec pour tout ce qui est "vrai travail".

    Pour une introduction lire https://therning.org/magnus/archives/tag/parsec

    Ce lien est maintenant au therning.org/magnus/posts/...; voir wiki.haskell.org/Parsec Sec. 5.2 pour les autres liens dans la série et des ressources supplémentaires

    OriginalL'auteur Jonke