Faire un don ! | | style | statistiques | contactez-nous | plan | lettre d'information

: Un nouveau serveur SMTP est né : Tethys, entièrement écrit en Lua

Posté par DarkGod (page perso, ). Modéré le 10 avril 2008.
Tethys est un nouveau serveur SMTP développé dans un but de simplicité (loin donc des cauchemars de configurations tels que sendmail) d'extensibilité et de modernisme.

Au programme, un serveur totalement écrit en Lua, extensible par un mécanisme de greffons, qui gère le format maildir++, les utilisateurs virtuels par SQL, une authentification SMTP simple, un fichier de configuration lisible...

Précision importante, Tethys est bien sûr Open Source en licence GPL3. Le premier exemple d'utilisation grand public de Tethys, le site d'emails temporaires MailCatch.com.

> Lire la dépêche (80 commentaires, moyenne: 2,8).  

Vous avez demandé le commentaire #922000.

Différences entre Lua et OCaml ?

Posté par ddevito (page perso, ) le 10/04/2008 à 11:50. (lien). Évalué à 1.

A première vue, Lua présente qques traits communs avec OCaml, par ex, le fait que les fonctions soient des citoyens de 1ère classe.

Est-ce que qqu'un qui connaitrait les 2 langages (on peut tjrs réver) peut préciser ici les différences entre les 2 ?
Merci

Soyons fou : quid d'une traduction (grandement automatique ? semi-automatique ?) de Lua vers OCaml par ex ?

  • [^]Re: Différences entre Lua et OCaml ?

    Posté par Mildred (Jabber id, page perso, ) le 10/04/2008 à 12:19. (lien). Évalué à 4.

    Je connais bien Lua, mais pas du tout Ocaml. Mais un point qui semblerait un peu bloquant est qu'en Lua, la structure des tables est à la base du langage.

    Les tables sont la seule structure de donnée du langage. Cela peut être utilisé comme un vecteur (on indexe par des entiers, les accès sont optimisés), comme un tableau associatif, comme une structure, comme un ensemble (les clefs sont les éléments de l'ensemble, les valeurs sont juste là pour indiquer si l'élément est présent ou non).

    Et pour étendre les tables, on a ce qu'on appelle les métatables. Ce sont des tables attachées à des objets (généralement des tables, mais pas forcément). Les fonctions stockées à des index particuliers de la métatable permettent de modifier un comportement par défaut.

    Par exemple, si la métatable d'un objet contient un objet à l'index "__index", alors lorsqu'on execute obj.key (qui en passant est juste un raccourci syntaxique pour obj["key"]), la fonction (mataméthode) sera appelée avec les paramètres obj et "key", et son résultat sera le résultat de l'expression obj.key.

    Cela permet entre autre d'implémenter des modèles orientés objets dans le langage. Car à la base Lua ne propose aucun modèle objet. Cela vient avec des bibliothèques extérieures comme LOOP http://loop.luaforge.net.

    [^]Re: Différences entre Lua et OCaml ?

    Posté par loufoque () le 10/04/2008 à 14:31. (lien). Évalué à 10.

    Lua et OCaml n'ont rien à voir.
    Si tu dois penser que tous les langages qui ont les fonctions en tant que first-class citicizens sont similaire à OCaml, alors 95% des langages de programmation le sont.

    Une différence fondamentale entre Lua et OCaml c'est que déjà Lua est typé avec du duck-typing, alors que OCaml c'est du typage statique avec inférence et polymorphisme paramétrique.

    • [^]Re: Différences entre Lua et OCaml ?

      Posté par seginus () le 10/04/2008 à 19:47. (lien). Évalué à 10.

      C'est pas faux.

      • [^]Re: Différences entre Lua et OCaml ?

        Posté par Larry Cow () le 10/04/2008 à 21:03. (lien). Évalué à 10.

        C'est typage statique avec inférence, que tu as pas compris?

        Ou bien polymorphisme paramétrique?

        • [^]Re: Différences entre Lua et OCaml ?

          Posté par TeXitoi (Jabber id, page perso, ) le 11/04/2008 à 14:07. (lien). Évalué à 6.

          typage statique : Le travail sur les types est intégralement fait à la compilation (donc rien n'est fait à l'exécution). Le contraire est typage dynamique, comme python, perl, ruby... Deux avantages à cela:
          - aucune verification de typage n'est nécessaire à l'exécution, ce qui fait gagner du temps à l'exécution.
          - La vérification est faite à la compilation, donc si les types utilisés sont incohérents, le code ne compile pas, contrairement au typage dynamique, où une exception est levé à l'exécution.

          inférence de type : il n'y a pas besoin de donner les types des variables, le compilateur les infèrent à partir du code. Par exemple :
          let f n = string_of_int nLe compilateur va trouver tout seul que le type de n est entier et que le type de retour de la fonction est chaîne de caractères.

          polymorphisme paramétrique : C'est la possibilité pour un type d'englober un ensemble de type, avec des paramètres permettant une réutilisation du type plus loin. Par exemple :
          let to_list n = [n]la fonction to_list prend un paramètre (qui peut être de n'importe quel type) et le transforme en une liste de type "liste d'éléments du type du paramètre. Le fait que la fonction puisse prendre un paramètre de n'importe quel type est le polymorphisme, le fait de pouvoir exprimer le type de la fonction grâce au type du paramètre est le paramétrique. Le code au dessus a pour type : 'a -> 'a list ce qui signifie une fonction prenant comme paramètre un paramètre de n'importe quelle type que l'on appelle 'a, et qui retourne une liste de type liste de 'a.

      [^]Re: Différences entre Lua et OCaml ?

      Posté par Stéphane Davy () le 11/04/2008 à 13:08. (lien). Évalué à 3.

      Dans quel(s) livre(s) apprend-on à parler comme ça?

      • [^]Re: Différences entre Lua et OCaml ?

        Posté par caouis () le 11/04/2008 à 14:55. (lien). Évalué à 2.

        Tu peut commencer par regarder wikipédia : type_informatique
        mais tu trouvera plus d'information en anglais.

        sinon il n'y a pas beaucoup de livre la dessus le seul que je connaisse c'est celui la : http://www.cis.upenn.edu/~bcpierce/tapl/