Salut Marc, J'allais répondre comme Sylvain, mais effectivement c'est un peu dangereux de faire ça (à moins d'être certains d'un unique élément séparateur dans la liste initiale), et il y a peut-être une façon moins risquée de traiter cette liste en amont pour éviter de faire ça. N'hésite pas à décrire un peu plus ce que tu souhaites faire si tu veux d'autres idées. - Valentin On Tue, Jun 20, 2017 at 12:45 AM Sylvain Henry <sylvain@haskus.fr> wrote:

Salut,

Tu peux utiliser un pattern dans un let.

...

let [x,y] = splitWhen (==0) [1,2,3,0,4,5,6] x [1,2,3] y [4,5,6]

Par contre il faut être sûr que le pattern est valide sinon:

*** Exception: <interactive>:5:5-43: Irrefutable pattern failed for pattern [x, y]

-Sylvain

On 20/06/2017 09:37, Marc Chantreux wrote:

...

salut a tous,

je cherche a prendre le resultat d'un splitWhen pour affecter directement deux variables. naivement (venant de perl), j'aurais tendance à écrire:

let votes, candidates = splitWhen (/= "0") $ lines getContents

sauf que ca ne marche pas et google ne m'a pas été d'un grand secours (probablement parceque j'ai un pb de mot clef).

si qq1 a une idée ...

cordialement,

_______________________________________________ Haskell-fr mailing list Haskell-fr@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-fr

salut a tous, merci pour vos réponses qui me permettent de continuer mon experimentation. Pour le moment c'est fragile et naif mais l'idée est d'apprendre. https://gist.github.com/anonymous/a416bad03ac5ddbfcbe5c8812c9a7467 l'idée (qui nous a été soumise comme un petit challenge par un membre du club local de developpeurs) est de télécharger et d'exploiter https://vote.gnome.org/blt.php?election_id=25 qui est le résultat d'un stv https://en.wikipedia.org/wiki/Single_transferable_vote en plus de pouvoir se poser des questions intéressantes, c'est aussi un bon terrain de jeu pour haskell: on peut clairement avoir une approche simple et naive et puis repasser dessus pour faire des choses réalistes (y'a bien un moment ou je vais degainer attoparsec :) ). encore merci. marc

salut, On Wed, Jun 21, 2017 at 02:20:05PM +0200, Simon Marechal wrote:

C'est typiquement un cas où tu peux utiliser "break", pour séparer votes/candidats.

sauf que je me suis rendu compte apres coup que l'appliquais un traitement bien different aux 2 parties du fichier pour obtenir les 2 listes et que je ne sais pas comment l'écrire. je suis donc parti avec un takeWhile et un dropWhile.

De plus, tu peux également utiliser "words" pour récupérer ta liste de chiffres, sans avoir à utiliser une quelconque bibliothèque de parsing.

c'est bien ce que je fais pour le moment ... mais c'est fragile! quid d'une chaine de plusieurs mots entre quotes par exemple. en perl j'ai les regexp que je peux dégainer facilement mais pour le moment je me sens un peu a poil avec haskell. bon j'ai quand meme avancé et j'en suis a trier les clusters de candidats par nombre d'occurrence. si qq1 a des idées de correction qui lui viennent a brule-pourpoint: https://gist.github.com/anonymous/c147082931d7dbebabab862ec33757d9 -- Marc Chantreux (eiro on github and freenode) http://eiro.github.com/ http://eiro.github.com/atom.xml "Don't believe everything you read on the Internet" -- Abraham Lincoln

Je t'ai mis un commentaire dans ton gist avec une technique très classique pour compter le nombre d'occurences d'éléments d'une liste. Le 22 juin 2017 à 17:46, Simon Marechal <simon@banquise.net> a écrit :

Tu peux:

let (lvotes,lcandidats) = break (== "0") lignes votes = ... a candidats = map read (drop 1 lcandidats) -- ça marche avec l'exemple que tu as donné ;)

Mais oui, dans l'absolu faut parser correctement ...

Le 22 juin 2017 à 17:29, Marc Chantreux <khatar@phear.org> a écrit :

...

salut,

On Wed, Jun 21, 2017 at 02:20:05PM +0200, Simon Marechal wrote:

...

C'est typiquement un cas où tu peux utiliser "break", pour séparer votes/candidats.

sauf que je me suis rendu compte apres coup que l'appliquais un traitement bien different aux 2 parties du fichier pour obtenir les 2 listes et que je ne sais pas comment l'écrire. je suis donc parti avec un takeWhile et un dropWhile.

...

De plus, tu peux également utiliser "words" pour récupérer ta liste de chiffres, sans avoir à utiliser une quelconque bibliothèque de parsing.

c'est bien ce que je fais pour le moment ... mais c'est fragile! quid d'une chaine de plusieurs mots entre quotes par exemple. en perl j'ai les regexp que je peux dégainer facilement mais pour le moment je me sens un peu a poil avec haskell.

bon j'ai quand meme avancé et j'en suis a trier les clusters de candidats par nombre d'occurrence. si qq1 a des idées de correction qui lui viennent a brule-pourpoint:

https://gist.github.com/anonymous/c147082931d7dbebabab862ec33757d9

-- Marc Chantreux (eiro on github and freenode) http://eiro.github.com/ http://eiro.github.com/atom.xml "Don't believe everything you read on the Internet" -- Abraham Lincoln _______________________________________________ Haskell-fr mailing list Haskell-fr@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-fr

clustersOf s = filter ((== s) . length) . map (take s) . tails clusters_of size list = map (take size) $ map (`drop` list) [0..length list - size] La différence est je pense principalement une question de goût. Je trouve évidemment ma version plus simple à comprendre ;) Après on peut faire presque pareil comme ça: clustersOf s lst = map (take s) $ take (length list - size) $ tails lst Le 23 juin 2017 à 11:03, Marc Chantreux <khatar@phear.org> a écrit :

hello,

On Thu, Jun 22, 2017 at 06:04:34PM +0200, Simon Marechal wrote:

...

Je t'ai mis un commentaire dans ton gist avec une technique très classique pour compter le nombre d'occurences d'éléments d'une liste.

merci beaucoup! je (re?)découvre l'existence de <$> (comment ai-je pu vivre sans?)

premiere question qui me vient: tu proposes

clustersOf s = filter ((== s) . length) . map (take s) . tails

ou j'ai écris

clusters_of size list = map (take size) $ map (`drop` list) [0..length list - size]

j'aurais tendance a préferer ma solution qui ne necessite pas de filtrage. pourrais-tu me dire ce qui te motivait en écrivant ta version?

pour le reste: lecture à la prochaine pause.

-- Marc Chantreux (eiro on github and freenode) http://eiro.github.com/ http://eiro.github.com/atom.xml "Don't believe everything you read on the Internet" -- Abraham Lincoln _______________________________________________ Haskell-fr mailing list Haskell-fr@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-fr

hello, On Thu, Jun 22, 2017 at 05:46:17PM +0200, Simon Marechal wrote:

let (lvotes,lcandidats) = break (== "0") lignes votes = ... a candidats = map read (drop 1 lcandidats) -- ça marche avec l'exemple que tu as donné ;)

certes mais je produits un lvotes qui ne sera jamais utilisé que pour produire votes. idem pour lcandidats. est-ce pertinent en terme de perf ? est-ce plus rapide de faire break plutot que takeWhile puis dropWhile ?

Mais oui, dans l'absolu faut parser correctement ...

dans mes reves les plus fous, je pousse un parser BLT sur hackage dans qq temps. merci en tout cas pour les commentaires. -- Marc Chantreux (eiro on github and freenode) http://eiro.github.com/ http://eiro.github.com/atom.xml "Don't believe everything you read on the Internet" -- Abraham Lincoln

Par contre, si tu as vraiment d'importantes contraintes de performances, il faudra travailler d'une façon totalement différente. En particulier, il y a fort à parier qu'il ne soit pas possible de charger tout le fichier en mémoire!

pour le moment je n'ai de contrainte que le fait d'apprendre mais j'aimerais bien dans un futur proche commencer a remplacer du vieux code a moi (du vieux c/shell/perl) par des équivalents haskell. -- Marc Chantreux (eiro on github and freenode) http://eiro.github.com/ http://eiro.github.com/atom.xml "Don't believe everything you read on the Internet" -- Abraham Lincoln