Reprise du message précédent :

concept error, abort

Est-ce que quelqu'un se sert de qtHaskell ici ?

Oh, je ne savais même pas qu'un tel binding existait !
En passant le binding le plus abouti et le plus documenté pour réaliser des GUI en haskell est gtk2hs, je pense que tu connais déjà.

Je dois avoir du caca devant les yeux, mais...
 
J'ai ca :

 
Je veux la longueur d'un chemin. Je suis a peu près persuadé que c'est tout con, et que ca se fait en appliquant deux bêtes fonctions, mais je ne trouve pas mieux que ca :
 

 
des idées ?

pathLength [_] = 0
pathLength (t1:t2:ts) = distance t1 t2 + pathLength (t2:ts)

?
 
Sinon tu peux jouer avec des combo de zip, uncurry, liftM, mapM et autres, mais ça va rendre ton code plus compliqué qu'autre chose je pense (par contre tu pourrais arriver à du pointless pointfree)

ce qu'il me manquait, c'était la premiere ligne de ton pattern, j'aurais cru qu'il aurait tout matché comme ca, mais en fait, c'est assez logique.

Ya pas de virgule dans le pattern

Bon c'est decide je vais apprendre un langage fonctionnel. J'hesite entre LISP et Haskell... LISP parce que pas mal de gens en parlent comme le langage divin et haskell parce que les tutos ont l'air plus conviviaux

Lua ?

C'est absolument pas un langage fonctionnel

Problème de Lisp: lequel? Parce que Lisp fondamentalement (en dehors de Lisp 1.5 qui a >45 ans ans) c'est un meta-langage, pas un langage. Donc il faut choisir ton Lisp. Clojure? Scheme? Common Lisp? …

Problème de Haskell: très très très statiquement & fortement typé, si t'aimes pas les types, ça va être insupportable.

Les tutos Haskell sont effectivement habituellement supérieurs, et la communauté est plus active & flexible (surtout ces temps ci), c'est un avantage notable. Il y a 25 miyons de tutos sur les monades, c'est pas un avantage.

Je t'avoue que je ne connais meme pas les differences entre les implementations de LISP...
 
Une fois le haskell appris, c'est facile de passer a LISP ( est-ce que c'est equivalent a passer d'un langage OO a un autre langage OO ) ?

Passer d'un langage OO à un autre langage OO n'est pas nécessairement facile

 
bcp de personnes le disent

Soit, ca prend un peu de temps, mais si les notions de POO sont bien acquises ca se fait en douceur ( je parle d'un programmeur avec une "culture" correct, pas un debutant qui ne connait que le java par exemple ).

Heuu bof hein, passer d'un C++ ou un Java à du Smalltalk (sans parler d'OCaml) par exemple c'est pas trivial du tout

Quand à "culture", ça veut rien dire.

Le seul truc que je peux te dire, c'est qu'apprendre un langage fonctionnel quand tu sais déjà "penser" en fonctionnel c'est naturellement plus simple que quand tu viens intégralement du monde impératif. Après est-ce qu'il est facile/trivial de passer d'un langage FP à un autre, pas nécessairement, ça dépend des langages considérés.

C'est vrai.
Bon ce sera haskell    
 

C'est surtout, à mon avis, un problème de syntaxe, autant celle des Lisp est simple, autant celle de Haskell (me) parait compliquée, le mode de pensée est le même mais l'écriture ...

La syntaxe de Haskell est clairement beaucoup plus compliquée que celle d'un lisp, mais à l'usage elle passe vraiment bien (surtout en utilisant les offside rules), globalement elle est bien pensée. Les gros problèmes avec Haskell ne sont pas tant la syntaxe que la tendance des gens à utiliser des opérateurs plutôt que des fonctions (on peut créer ses opérateurs customs et en gros tous les caractères qui ne sont pas dans [0-9a-zA-Z_] sont utilisables pour les nommer, donc ça fait un peu soupe), et le style pointfree, franchement dur à lire quand on est pas habitué.

C'est vrai que les types c'est un peu chiant en fait
Mais sinon pour l'instant c'est tres interessant a apprendre ( meme si j'ai encore un peu de mal a voir ou je pourrais m'en servir ).

Comme ils le disent dans la communauté haskell, faut apprendre à penser en types. C'est pas si fréquent en prog au final.

Par curiosite j'ai parcouru quelques artcles sur les monades  
Pas bien capte encore  

J'ai ça en Haskell  
 

getFileHeaders f = do
    isFile <- doesFileExist f
    if not isFile
        then return []
        else do
            contents <- readFile f
            return (takeWhile (isPrefixOf "//" ) (lines contents))

            
getFileHeaders' f = do
    isFile <- doesFileExist f
    if not isFile
        then return []
        else do
            inFile <- openFile f ReadMode
            contents <- hGetContents inFile
            return (takeWhile (isPrefixOf "//" ) (lines contents))

 
Je note 0.20 secs de différence entre les deux fonction sur 150 fichiers de 2 mo (60 000 lignes). Hors j'ai cru comprendres que readFile consommait la totalité du fichier là où hGetContents était totalement lazy. J'ai raté un truc?

Scala pour commencer le fonctionnel (par curiosité, pas en environnement pro) en venant du monde Java, oui ou non ?
 
Si oui, de bons tutos, un point pour commencer ? Bonux : une idée de mini-projet(s) pour l'apprentissage, sachant que j'ai pas d'autre but que celui-ci.

jQuery 1.6 beta1 released

http://blog.jquery.com/2011/04/15/jquery-16-beta-1-released/

Euh...

A taste of Haskell

http://ontwik.com/haskell/simon-pe [...] f-haskell/

Chu pas sûr que ça intéresse les langages fonctionnels, en revanche

Merde qu'est ce que j'ai branlé

Fixed

 
Bon, j'y étais un peu allé les yeux fermé, Scala c'est un langage objet avec des paradigmes fonctionnels, un peu à la Ruby. Du coup, c'est certainement pas l'idéal pour apprendre la prog fonctionnelle, je vais pourtant rester là dessus pour le moment.
 
Je réitère ma demande d'exo type / mini projet, un cas d'école pour introduire les concepts fonctionnels ou qui se résolve trivialement / élégamment par ce biais, ça serait top pour commencer

En Scala, je cherche à déterminer le "meilleur" objet d'une liste.

Soit par exemple :

class Arc(val cost:Int)

le meilleur Arc est celui qui à le cost le plus faible. Je passe par un foldLeft sur la liste et un pattern matching, mais je me demande si c'est la bonne méthode (idiomatiquement et d'un point de vue fonctionnel, j'ai jamais fais de fonctionnel et je suis nouveau dans le langage).

val closestArc = arcs.foldLeft(null: Arc) { (nearest, current) =>
  nearest match {
    case null => current
    case arc: Arc => if (arc.cost > current.cost) current else arc
  }
}

Avis, critiques ?

Pourquoi ne pas juste utiliser `TraversableOnce#min`

Parce que je ne connaissais pas
J'ai juste l'impression que pour tout ce que je cherche à faire, il y a une méthode prévue dans la lib, et que même si je passe devant, il me faut 10 minutes de Google pour en effleurer le mécanisme.

Les folds sont des mécanismes de relativement bas niveau, pour des opérations simples de filtration ou transformation il est rare de devoir y recourir

J'essaie de transformer du code impératif, je bloque sur un problème de définition d'une range (en remplacement d'une condition d'arrêt dans une boucle).

Soit (Scala, mais je pense que ça n'a pas d'importance) :

var i = 3
while (i * i <= x) {
  if (/* condition sur x et i */) return false
  i += 2
}

Je le traduit par :

// Définition d'une range de 3 à racine carrée de x par pas de deux
val range = (3 to scala.math.sqrt(x).intValue()).by(2)
!range.exists(/* condition sur x et _ */)

Pas de soucis, sauf de perf, j'ai un facteur 5 de différence, bien évidemment dû à l'utilisation de sqrt (voir edit). D'où ma question, comment je peux définir une range en fonction d'une condition d'arrêt ? Ou alors c'est simplement pas la bonne méthode et j'attaque ça du mauvais côté ?

Edit : je me suis aussi dit que ça pouvait venir du fait que exists va chercher dans toute la liste là ou le parcours s'arrête si la condition match avec le while, sauf qu'en remplaçant par :

val range = (3 to scala.math.sqrt(x).intValue()).by(2)
// find retourne le premier résultat matchant la condition
range.find(/* condition sur x et _ */) == None

j'ai toujours mon facteur 5 sur le temps d'exécution par rapport à la version while.

C'est bien évidemment pas une préoccupation sur la performance, si je généralise, ma question est de savoir si je peux trouver un équivalent fonctionnel à la condition d'arrêt dans une boucle pour des cas particuliers, ou si pour ces cas, je dois me contenter d'un :  
 

for (i <- (3 to x).by(2)) {
  if (i * i > x) return true
  if (/* condition sur x et i */) return false
}
true

 
(rapport au while du post précédent)
 
Question bonux (perf quand même, mais surtout par curiosité) : le for précédent à un facteur 2 sur le temps d'exécution par rapport au while de mon précédent post, je vois pas ce qui le justifie.
 

takeWhile?

 
While est une vrai boucle. For une methode qui prend une closure comme argument (y a des effort pour l'optimisation sur les versions futures, mais c'est pas encore le cas).
 
T'as interet a lire le bouquin d'Odersky si tu te poses ces questions de base sur Scala.

Oui et non. TakeWhile simule bien la condition d'arrêt, mais le fait dans sa propre itération (pas celle où je passe mon prédicat), si bien que :

range.takeWhile(i=>i*i<=x).exists(/* condition sur _ et x */)

fonctionne, mais double la complexité.

 
Il est dans mon sac, j'ai dû sauter la partie ou l'oublier. Merci pour la clarification
 

range.takeWhile(i=>i*i<=x).exists(/* condition sur _ et x */)

Dépend de la manière dont le langage fonctionne, si tu as des itérateurs/générateurs et non des listes la complexité restera O(n) (un élément donné fera toute la chaîne d'opérations en une fois). Et le langage peut même appliquer des optimisations pour réduire le facteur constant (je doute que ça fonctionne en Scala, mais haskell fait du stream fusion)

>>> def tw(x):
...     print 'takeWhile', x
...     return i < x < i*i
... 
>>> def m(x):
...     print 'map', x
...     return x*2
... 
>>> i = 4
>>> list(imap(m, takewhile(tw, xrange(5, 10))))
takeWhile 5
map 5
takeWhile 6
map 6
takeWhile 7
map 7
takeWhile 8
map 8
takeWhile 9
map 9
[10, 12, 14, 16, 18]

Vu les résultats, l'optim est pas présente.