Informatique

Oui c'était le but de faire l'équivalent de façon plus ou moins "pythonic".

Une liste en compréhension c'est un truc qui te permet de filtrer une liste avec des conditions et chaque élément retourner ce retrouve à gauche totalement de l'expression (tu peux appliqué une transformation à l'élément comme j'ai fait avec * 2)

C'est une features très populaire dans Haskell

En gros c'est juste plus ou moins du sucre syntaxique pour looper dans une liste, faire des transformations sur les éléments, filtrer les éléments, et le résultat de l'expression finale est une autre liste.

Et non, je ne crois pas qu'il existe un truc similaire pour Ruby. Enfin pas en natif en tout cas.

C'est ce qui me manquait le plus pour les 2-3 trucs que j'ai fait sous Rails.

En ruby tu peux faire l'équivalent avec reject Enfin ça marche dans l'autre sens mais suffit d'inverser la valeur de vérité et c'est équivalent.

Richard > Aaaaaaaaaaahh oui, je vois ça en Haskell mais j'imaginais pas du tout les revoir ailleurs que dans le Haskell donc j'ai pas tilté

Hum, là tout de suite je dirais qu'on peut bricoler un truc avec reject ou select, à voir.

Jamy >
"Il ne s'agit pas de débuter, je pense qu'une fois que tu es sorti d'un cursus de 5 ans d'enseignement en Informatique alors tu peux utiliser Ruby. Dans le cas contraire c'est néfaste et non adapté. Je parle pour des personnes qui souhaitent apprendre l'informatique en tant que science. "

Mais c'est le cas de n'importe quel langage plus ou moins haut niveau
La programmation n'est qu'une infime partie des CS, et un langage en particulier en est une partie encore plus infime. C'est juste de la grammaire et un peu de mémoire ; le vrai boulot, c'est toute la théorie derrière sur les structures de données et les algorithmes.
Peu importe ton niveau dans ces théories informatiques, le langage n'est qu'un outil pour les appliquer. Si je n'ai aucune connaissance en théorie des catégories, ce n'est ni l'assembleur ni le ruby qui me l'apprendront. Et si je suis un expert en théorie des catégories, ce n'est ni l'assembleur ni le ruby qui m'empêcheront ni m'aideront à les appliquer si j'en ai besoin.

Je vois pas où tu veux en venir, en fait. Bien sûr qu'un langage ne t'apprendra pas les CS, c'est une discipline à part entière et dont les langages font partie ! Je le répète, mais un langage est un outil et en soi un simple conglomérat de règles de grammaire et de mots-clés. Tout le travail derrière est plus abstrait que ça et applicable à n'importe quel autre langage.

l'inverse de reject c'est select.

Mais ouais avec select et collect, on peut faire un truc semblable, mais en moins beau syntaxiquement.

Comme tu l'as dis un langage est un outil, quand on enseigne une théorie qu'on découpe en UE puis en différentes parties on a la partie théorique d'un côté puis la partie pratique du cours. Qu'est-ce que la partie pratique en informatique ? C'est un langage de programmation. Du coup ça permet de faire le lien entre la théorie et la pratique. Et je te dis pas les dégâts si on utilisait Ruby pour ce faire par exemple

En mathématiques tu n'auras jamais le meilleur niveau possible si tu ne fais pas d'exercices, tu auras beau apprendre ton cours par cœur si tu n'es pas capable d'avoir l'abstraction pour dégager les concepts et comprendre leur étendue tu ne vaudras rien devant un sujet d'examen. Expérience vécue de nombreuses fois

C'est exactement la même chose ici.

Ouais je sais en plus Le pire c'est que j'ai toujours utilisé select et pas reject

Mais je veux bien, je suis tout à fait d'accord avec ton dernier message ; mais je vois pas en quoi le Ruby en particulier t'empêche de mettre en application tes connaissances théoriques.
Qu'est ce que tu peux faire manuellement en C, en Python ou en je-ne-sais-quoi que tu ne peux pas faire manuellement en Ruby, si tu veux implémenter tes cours ?
Comme je te l'ai dit, toutes les abstractions offertes par Ruby sont optionnelles. Si tu veux réimplémenter toi-même une structure de données ou un ensemble de méthodes en particulier, tu dispose toujours des mêmes outils primaires que dans n'importe quel autre langages : boucles, embranchements, structures de données primitives, ...

Vraiment, comme j'avais dit je pense pas effectivement que le Ruby soit le meilleur pour débuter, mais pas du tout pour ces mêmes raisons. Selon ton raisonnement, aucun langage n'est adapté puisque le principe est justement d'appliquer des théories abstraites, mais pour ce faire il faut forcément descendre en abstraction !

http://xkcd.com/378/

Premièrement la faiblesse, si je dispose d'un tel langage je vais être tenté par le diable et utiliser ces méthodes

Deuxièmement même dans la plus grande simplicité Ruby reste un langage de plus haut niveau ne serait-ce que dans son interprétation des structures primaires

Du coup Ruby n'est pas approprié il équipé de beaucoup trop de raccourcis, sa gestion de la mémoire est complètement transparente.

Mais oui grosso-modo CRuby est écrit en C donc tu peux faire tout ce que tu fais en C, mais il y des simplifications fondamentales.

Ce n'est pas parce que c'est abstrait que ça n'a pas de sens dans la pratique, si tu n'as pas l'abstraction nécessaire ta pratique en souffrira car tu n'auras pas LA manière de raisonner.

https://www.jeuxvideo.com/forums/1-38-7818315-1-0-1-0-archlinux-cette-blague.htm#message_7818317

Les produits eco+ c'est très bien

Encore un prolo

Sinon Calet on peut conduire sur la route avec une Clio mais on peut également conduire avec une BMW. Pourtant il est plus judicieux d'apprendre en Clio qu'en BM

Et non ce n'est pas parce que la twingo coûte moins cher que la BM

:troll:

clio*

Oui G_B m'a kické cet enflure

Sinon bordel j'ai trop de mal à faire cette fonction dans ma tête

maximum' :: (Ord a) => [a] -> a
maximum' [] = error "maximum of empty list"
maximum' [x] = x
maximum' (x:xs)
| x > maxTail = x
| otherwise = maxTail
where maxTail = maximum' xs

C'est un truc de ouf comment je suis une quiche en récursion, encore les trucs simples comme factorielle ou fibo tranquille mais là je suis dépassé

Quelqu'un de très gentil pourrait dérouler l'algorithme de manière très détaillée avec un exemple simple type maximum'[3,1,2] ?

Bah oui mais bon je passe mon temps à vous répéter de laisser ce genre de topics couler
(surtout quand c'est l'autre consanguin qui les rédige quoi )

Ouais enfin je savais pas que c'était un rédivisiste moi

Sinon c'est bon j'ai compris c'est d'une telle puissance le langage fonctionnel. Merci Calet de m'avoir lancé dedans, j'hésitais encore entre le biff (ingé ) et la recherche vraiment je pense que le choix est vite fait quand je vois à quel point ces choses sont fascinantes

Vas y je vais bien assimiler la logique et la syntaxe et je me refais projet euler en Haskell

Bah, tu verras on le reconnait facilement, c'est celui qui ne sait pas écrire et essaie de me faire bannir/destituer tous les deux mois en moyenne

Jamy > est-ce que tu as déjà de l'expérience avec des langages type Lisp ? La notion de car et coulder/cdr (x:xs) pourrait déjà t'aider à comprendre.
Si tu veux un peu d'aide sur la récursion, regarde le bouquin The Little Schemer, qui présente des aspects fascinants de la récursion avec Scheme. Attention à la fin c'est costaud, on passe d'un bête tri de liste récursif à des démonstrations mathématiques complètes

Sinon pour ton algo :
"maximum' :: (Ord a) => [a] -> a " Signature de la fonction : elle prends une liste d'élément de type a où a est un type ordonnable et renvoie un élément de type a.

"maximum' [] = error "maximum of empty list" En Haskell on peut faire des 'surcharges' de fonctions instantanées selon le type et la taille des arguments. Ici, in lance une erreur si la liste est vide.

"maximum' [x] = x " On renvoie x si la liste ne contient qu'x.

"maximum' (x:xs) " Si on tombe ici, c'est qu'on a une liste d'au moins 2 atoms. On les sépare en deux, le car (x) et le cdr (xs). Le car est la tête de liste (premier élément), le cdr le reste.
C'est ici que ça devient intéressant (mais encore assez simple à suivre, on a pas de construction à faire lorsque le fil de récursion est 'rappelé'). Je remplace les variables locales pour plus de clarté.
" | x > maximum' xs = x " Si la tête de liste est supérieure au maximum du reste de la liste, alors la réponse est la tête de liste.
Exemple avec [3,1,2]. On compare 3 et [1,2]. On appelle donc maximum' sur [1,2] et on cherche à comparer 1 et 2. 1 est inférieur à deux, on passe au garde 'otherwise'. Cette fois-ci, le reste de la liste est seulement 2, donc on relance maximum', mais on tombe dans le cas maximum' [x] et donc on renvoit x, ici 2.
Hop, plus rien à faire ! On remonte le tas récursif. On a obtenu 2 en réponse à la première question qui voulait le comparer avec maximum' xs. Maintenant il faut faire une comparaison 3 > 2, ce qui est vrai. On reste bien dans le premier garde (on y était seulement entré avant de voir qu'il fallait d'autres appels récursifs pour y répondre) et donc on renvoit x, donc 3.
3 est bien le maximum de [3,1,2]

Et évidemment je viens juste de voir le message où tu disais que t'as compris

Si vous voulez apprendre le Haskell les autres profitez-en, je ne ré-expliquerai pas