benja a écrit 1211 commentaires

Vous montrez que fold avec une fonction d'accumulation et une graine et le fold avec fonctions f et g sont équivalent car il existe une fonction f et g pour n'importe quelle paire d'une fonction d'accumulation avec une graine. Et réciproquement. OK soit je peux convevoir que vous ayez raison. Mais mon propos n'est pas là.

Mon propos est qu'il est d'usage d'appeler la première version fold. Si j'avais l'habitude de sommer les feuilles de mon arbres avec fold (+) zero tree vous me demandez maintenant de l'écrire zero + (fold (+) (fun x -> x) tree). Alors ok ça fait la même chose mais en l'utilisant différemment. Je dis simplement que je trouves cela perturbant…

Alors je l'ai reprise.

Version courte: votre "fold" ne fait pas la même chose. C'est comme si un itérateur s'appelait map, ou encore un Queue.pop s'appellant Queue.empty, etc.

NB du NB: Aussi on ne peut pas inférer l'ordre de parcourt de par la signature… C'est pourquoi je n'ai vraiment rien compris au commentaire d'Aluminum95.

Ce que je veux dire c'est votre "fold" n'utilise pas d'initialisateur/accumulateur, ce n'est pas un fold/reduce à proprement parlé comme on est habitué avec Ocaml. (Peu importe si le concept mathématique que vous utilisez s'appelle fold ou pas ça n'est pas mon propos). Donc je suggère simplement d'utiliser un autre nom pour ne pas dérouter le novice.

(NB: la signature exacte (i.e. l'odre des arguments) a peu d'importance pour illustre mon propos, ce n'est qu'un détail d'implémentation c'est pourquoi il ne faut pas trop s'attacher à la signature que j'ai donné, les deux version List.fold_left/righ ou encore celle de ocamlgraph qui sont toutes différence mais néanmoins "équivalentes" en ce sens qu'elle demandent toutes un initialisateur ce qui permet éventuellement d'enchaîner plusieurs folds à la suite sans trop de difficulté).

Quant à l'ordre de visite je ne comprends toujours pas le rapport que ça a avec cette discussion de savoir s'il est pertinent d'appeller quelque chose fold alors que ça n'en est pas vraiment un au sens ocaml (oulla je prends des pincettes cette fois :p). Désolé d'avoir été peu clair, je comprends bien l'importance de connaître l'odre d'évaluation et c'est effectivement mieux de le spécifier dans le nom de la fonction directement. Mais bon je ne sais pas lire dans les pensées d'Aluminium95 donc bon je crois que l'on va en rester là ;-)

edit: en parlant de clojure, et après vérification, son fold serait un combine+reduce, il n'est pas clair que celà soit un catamorphism au sens dont vous l'entendez (dans certaines conditions, j'imagine que cela pourrait-être). Par contre son reduce a bien la même signature que le fold d'ocaml usuel (ce que j'avais par ailleurs déjà mentionné dans mon commentaire initial). Alors peut-être que le fold d'ocaml est mal nommé, néanmoins il me semble logique de garder la même nomenclature lorsqu'on travaille au sein d'un même langage.

Alors il suffirait de l'appeler "catamorphism" si c'est ce que l'on veut, non ? Que ce soit librairie standard d'Ocaml, ocamlgraph ou clojure, tous utilisent la même convention pour la fonction fold, qui est celle que j'ai montrée. Je ne comprends pas ce que vous voulez dire en parlant de l'ordre de parcourt.

Bon je vais encore passer pour un gricheux en disant que le fold de votre exemple est un peu bizard car il n'a rien d'un fold (aka reduce dans d'autre parlances). Il devrait avoir comme signature ; 'a coll -> 'b -> ('b -> 'a -> 'b) -> 'b. 'b est le type de la valeur initiale (qui devrait être la chaîne vide dans votre cas) et est aussi le type du résultat (une chaîne). Bref Je suis d'avis que lorsque l'on réutilise des noms de concepts qui ont une définition bien établie, autant utiliser le concept ou adopter une autre terminologie. Et ce d'autant plus pour un document pédagogique !

Autre détail: il me semble que vos définitons des fonctions show_xx souffrent d'un "do not repeat yourself". C'est un peu dommage de présenter un language fonctionnel (i.e. ou le calcul in fine est basé sur la composition de fonction) et de rater une si belle occasion de montrer un code qui pourrait être encore plus élégant. 'fin bon, les couleuvres toussa

Cela tient en 3 lignes…

Le lecteur attentif aura sûrement corrigé, la première ligne est inutile car la variable verbe n'est pas utilisée (et comme print_endline tout seul n'est pas une application, il ne peut y avoir d'effet de bord). Le compilateur émettra probablement un warning. Si on désire vraiment indiquer au relecteur que print_endline est un verbe, dans ce cas effectivement une annotation explicite de type peut-être utilisée; là où un commentaire ferait tout aussi bien l'affaire ;-)

type ('a,'b) verbe = 'a -> 'b ;;
let rec fois n f x= match n with _ when n <= 0 -> () | n -> f x; fois (n-1) f x
in (5 |> fois) (print_endline : _ verbe) "abc"

J'approuve totalement la volonté de vouloir faire connaître ce merveilleux langage qu'est Ocaml, cependant laissez moi poser quelques réserves quant à la pertinence pédagogique de vos exemples, qui sont tirés, si je me souviens bien, d'une discussion à propos des fonctionnalités syntaxiques de c++ (ce qui, convenons-en n'est certainement pas un excellent prémisse ;-) ).

Premièrement il me semble qu'il aurait été judicieux d'aborder la notion de curry-ing et d'application partielle. L'application partielle est ce qui fait que la fonction f : a -> b -> c (le : veut dire "a pour type", _ -> _ "est une fonction de _ vers _" et a,b,c sont des types), lorsqu'elle est appliqué à un l'argument x : a est une fonction qui a le type b -> c. Soit une fonction a n argument lorsqu'elle est appliqué à m < n arguments est une fonction à n-m arguments. NB: l'évaluation de l'expression finale a lieu lorsque l'application est complète.

En ocaml on écrit let f : a -> b -> c = fun a b -> (expr : c) in let f' : b -> c = f (a_expr : a) ou bien sans les annotations de types, qui sont généralement pas nécessaires, let f a b = c_expr in let f' = f a_exp ou a_expr et c_expr sont des expressions de type a ou c. Et ça c'est ce qu'on appelle le currying, c'est à dire de pouvoir associer à une variable une fonction partiellement appliquée. Un exercice pédagogique serait pour un lecteur curieux de copier coller vos exemples de manière partielle afin d'essayer de déduire à priori le type de l'expression résultante.

Deuxièmement, j'en avais déjà fait la remarque précédemment, mais selon moi ce genre de code a peu de sens:

let ecrire (adv:('a,'b,'c) adverbe):('string, 'c) verbe =
  fun texte -> adv print_endline texte;;

Dans votre exemple, et contrairement au normes du français que vous tentez de singer, écrire n'est ni un verbe (selon votre définition un verbe est une fonction a un argument), ni un adverbe, mais une fonction qui lorsqu'elle est appliqué à un adverbe et à un verbe donne un autre verbe. Ce qui est, vous en conviendrez je l'espère, un peu déroutant. Votre "écrire" est une sorte de méta-verbe qui se conjugue lui-même pour donner un autre verbe à l'infinitif. Je trouve que pour un document à vocation pédagogique c'est un peu tordu.

Déjà je suggère de substituer vos alias de type adv et verbe afin de retrouver le type "non-obfusqué".
En subsituant adv par sa définition ('a, 'b) verbe -> ('a, 'c) verbe, on obtient

ecrire : (('a, 'b) verbe) -> ('a, 'c) verbe) -> (string, 'c) verbe

Puis on substitue verbe ('a, 'b) verbe = 'a -> 'b:

ecrire: (('a -> b) -> ('a -> 'c)) -> string -> 'c

On obtient un type qui est inutilement compliqué.

Selon moi votre verbe c'est "écrire", c'est à dire print_endline (string -> unit), votre adverbe c'est "5 fois" qui a comme signature ('a -> unit) -> int -> ('a -> unit) ou encore int -> (a' -> unit) -> ('a -> unit) pour changer l'ordre des paramètres.

Cela tient en 3 lignes…

let verbe = print_endline in
let rec fois n f x= match n with _ when m <= 0 -> () | n -> f x; fois (n-1) f x
in (5 |> fois) print_endline "abc"

Il était grec, pas troyen /o\.

Il est probable que le firmware de la carte wifi n'est pas disponible. Dans ce cas, et pour répondre en vitesse, il suffirait alors de le copier sur le média d'installation ou sur un autre média amovible. Pour plus d'info voir https://wiki.debian.org/Firmware et la doc de d-i.

À priori, ton grub fonctionne comme il faut, ton noyau et ton initrd sont bien chargés. Tentes peut-être la regénération de l'initrd. Il se aussi peut que soit ton device block disque ne soit pas détecté, ou qu'il aie changé de nom ou que le driver ne soit pas dans l'initrd. Démarre sans le "quiet" pour vérifier que ton controleur disque est bien détecté.

Sinon ce lien décrit quelqu'un qui a eu les memes symptomes, cela peut peut-être t'aider à comprendre (ou pas) http://www.gossamer-threads.com/lists/linux/kernel/522517 .

Autres pistes: greasemonkey, python beautiful soup, phantomjs/mobdyleum/selenium, https://addons.mozilla.org/en-US/firefox/tag/automation, etc. Malheureusement toutes en contradictions avec tes requirements. Amha il faudrait que tu commences par pouvoir les changer, par exemple en argumentant par le calcul du cout horaire de cette tâche. L'idéal étant, je suppose, que l'import depuis ta source se fasse de manière automatique, c'est-à-dire supprimant l'étape "formulaire html manuel".

Le \x n'a rien d'obligatoire: la documentation précise simplement que la seule façon de mélanger des méta-commandes (celles qui influencent le comportement du client, par exemple \x pour activer un formatage étendu) et des requêtes sql c'est de piper dans psql. Par opposition à utiliser l'argument -c; par exemple psql -d madb -c "select xxx;". L'argument à -c ne permet que l'utilisation de commandes sql. Dans le cas, si l'on désire modifier le comportement de psql, il faut soit configurer le fichier .psqlrc ou activer d'autres options de la ligne de commande (p.e. -x sur la ligne de commande est équivalent à \x dans psql).

Es-tu l'auteur de l'entrée de ce forum ? J'ai vraiment du mal à croire que cat <<EOT | ssh cmd fonctionne différemment que ssh cmd <<EOT !

Si c'est le cas, qu'est-ce qui l'empêche de faire un nagscreen ? "Problem solved…"

C'est dommage de rester sur la défensive. Perso, j'avais justement une solution clefs en main… mais bon, bonne merde alors, c'est comme ça qu'on dit ?

s/table/db/

Ou comment ne pas résoudre un problème de manière structurelle… :p

</mode j'arrive après la bataille>

Pourrais-tu être plus explicite ? À priori il ne devrais y avoir aucune différence de comportement entre les deux versions.

Je suppose que le problème pourrait être du à une différence entre le mode batch et interactif de ssh: peut-être un alias shell ou une variable d'environnement non passée…? Vu que la table ne s'appelle pas user, ben je dirais qu'une solution serait de demander à psql de connecter à la bonne base (option -d iirc, à vérifier).

Note: une autre solution serait de configurer postgres pour écouter sur le réseau en TLS et configurer l'authentification de manière adéquate…

Amha ta base dpkg est ou a été corrompue… As-tu eu une coupure de courant avant d'avoir ces problèmes ? C'est peut-être aussi un signe de matos qui flanche… (ou alors tu joues avec des version de noyau buggées).

Ceci dit, par rapport à l'erreur que tu as, on dirait que c'est le paquet deb qui contient des infos erronées… Je ferais un apt-cache clean pour forcer le retéléchargement, et je recommencerais. Si ça n'aide pas, alors je tenterais un debsums -c et je réinstallerais tous les paquets marqués en erreur. Et si ça n'aide toujours pas, alors essayer de restaurer un backup de la base de donnée dpkg (depuis /var/backup/dpkg), si effectivement elle s'avère toujours corrompue… mais bon ça serait bien de trouver la cause, car c'est clairement pas normal d'avoir un système à ce point cassé… J'espère pour toi que tu as des backups de tes documents sur un autre matériel ;-)

C'est exactement ce que j'ai fait

Effectivement j'avais mal interprété.

PS2: je me dis parfois qu'un opérateur '$' à la haskell serait agréable à utiliser…

Il existe en OCaml, c'est le double arobase @@ :

Ah ça c'est cool, merci !

C'est étrange, peut-être le signe d'une défaillance disque ou d'un upgrade inadéquatement interrompu ?
Bref, un moyen de corriger cela c'est de les réinstaller: apt-get install --reinstall liste de paquets. Je te recommande l'utilisation de debsums pour vérifié l'intégrité des tous les paquets installés, et réinstaller si nécessaires les paquets corrompus de la même manière. Et après un apt autoremove pour enlever les paquets obsolètes.

Ce que je voulais dire, c'est qu'utiliser des artifices syntaxiques pour "transformer" la grammaire au lieu d'utiliser la grammaire de base rend la compréhension plus compliquée pour quelqu'un de familié avec le langage. Dans certains cas, c'est justifié, par exemple si cela serait trop verbeux, ou que la nouvelle syntaxe est communément utilisée (par exemple, la notation "do" pour un monad). J'ai aussi l'impression que l'on peut constater ce même mouvement vers une syntaxe "standardisé" avec la dépréciation de camp4 au profis de la nouvelle façon.

Si je reprends tes exemple, je n'aimes pas que le verbe soit paramètré par un adverbe, Je préfèrerais que l'adverse soit paramètré par le verbe et retourne un nouveau verbe, dans la plus simple tradition de la composition de fonctions, lambda power ;-). Cela renverse aussi la syntaxe usuelle lambda pour l'application de fonction, qui est (fonction arguments…). Sans utiliser d'opérateur customisé, il y a moyen de le faire, au prix d'une lisibilité légèrement diminuée. Après, cela reste une question de goût et une préférence pour le kiss :-)

PS: avec mon exemple, on peut aussi écrire (print_endline >| (5 |> fois)) "xxx", sans devoir réécrire quoi que ce soit. Par contre on ne peut pas s'affranchir des parenthèses… mais bon, je trouve ça un avantage, c'est justement l'argument que j'essaye de développer,
PS2: je me dis parfois qu'un opérateur '$' à la haskell serait agréable à utiliser…

Tu peux essayer d'installer la version précédente de apt-listchanges (http://snapshot.debian.org/package/apt-listchanges/3.2/ ), à installer avec dpkg -i lepaquet.deb. Sinon tu peux aussi supprimer apt-listchanges: dpkg --purge apt-listchanges.