IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Framework .NET Discussion :

[Article] Présentation de la classe Tuple du .NET Framework 4


Sujet :

Framework .NET

  1. #41
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par anthyme Voir le message
    Moi j'aime bien votre idée sauf pour le return. Je verrai bien un return dans ce style :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    return new (1,"toto");
    // ou 
    return (1,"toto");
    plutot que de retourner un type anonyme...
    Cela se discute. Ma philosophie : ne rien réinventer... ainsi je réutilise toutes la puissance existante des types anonymes
    Citation Envoyé par anthyme Voir le message
    L'avantage du tuple c qu'on peut renvoyer une liste de tuple dans le type de retour
    Et !? Qu'est ce qui m'en empêcherait avec ma définition !? Je te rappelle que c'est un vrai "type" à 100% Ainsi ces écritures seraient parfaitement viables :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    (int Key, string Value)[] array;
    List<(int Key, string Value)> list;
    ICollection<(int Key, string Value)> collection;
    ... Et même l'imbrication ! Mais je n'en vois pas encore l'intérêt

  2. #42
    Rédacteur/Modérateur


    Homme Profil pro
    Développeur .NET
    Inscrit en
    Février 2004
    Messages
    19 875
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Février 2004
    Messages : 19 875
    Points : 39 749
    Points
    39 749
    Par défaut
    Ouais... c'est pratique, mais ça améliore vraiment pas la lisibilité
    Quand il y 2 membres, ça va encore, mais s'il y en a 5 ou 10 ça devient complètement vraiment monstrueux

  3. #43
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par tomlev Voir le message
    Ouais... c'est pratique, mais ça améliore vraiment pas la lisibilité
    Quand il y 2 membres, ça va encore, mais s'il y en a 5 ou 10 ça devient complètement vraiment monstrueux
    Exacte... mais est-ce qu'un Tuple en devient plus lisible ?

    Je dirais même encore plus monstrueux pour le Tuple car ses noms de propriété sont seulement "génériques" (Item0, Item1, etc...) Donc pour s'y retrouver... bof bof.

    Et puis normalement "mon" type sert juste à la signature d'une méthode. Car un "var" peut suffire en utilisation local.

    Alors si tu dois sortir 5 ou 10 valeurs... qu'est ce qui est mieux ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    (int Key, string Nom, string Prenom, double Age) MyMethode(double x);
    Tuple<int, string, string, double> MyMethode(double x);
    void MyMethode(double x, out int Key, out string Nom, out string Prenom, out double Age);
    Franchement !?

    note : si vous avez un bon exemple avec au moins 5 membres, j'éditerai.

  4. #44
    Rédacteur/Modérateur


    Homme Profil pro
    Développeur .NET
    Inscrit en
    Février 2004
    Messages
    19 875
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 42
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Février 2004
    Messages : 19 875
    Points : 39 749
    Points
    39 749
    Par défaut
    Citation Envoyé par ijk-ref Voir le message
    qu'est ce qui est mieux ?
    A choisir, je crois que je préfère encore la version avec les paramètres out

    De toutes façons, dans un cas comme ça il vaut mieux créer une classe dédiée

  5. #45
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par tomlev Voir le message
    De toutes façons, dans un cas comme ça il vaut mieux créer une classe dédiée
    Ca c'est très très bas ! ...lui reprocher une utilisation que tu ne ferais même pas avec Tuple !
    Citation Envoyé par tomlev Voir le message
    A choisir, je crois que je préfère encore la version avec les paramètres out
    Je trouve ce raisonnement étrange ! Surement parce que j'ai toujours préféré l'écriture des fonctions comme en mathématique :

    f : R x S x T --> P x Q x R

    Je préfère une écriture "fonctionnelle", j'irai même à proscrire ces satanés "out".

    Je devrais peut-être me remettre au Camel avec F#

  6. #46
    LLB
    LLB est déconnecté
    Membre expérimenté
    Inscrit en
    Mars 2002
    Messages
    967
    Détails du profil
    Informations forums :
    Inscription : Mars 2002
    Messages : 967
    Points : 1 410
    Points
    1 410
    Par défaut
    Citation Envoyé par ijk-ref Voir le message
    Je devrais peut-être me remettre au Camel avec F#
    Avec F#, tu ne fais pas du Caml, tu fais... du F#.

    Si tu as une fonction C# qui utilise "out", tu peux l'utiliser en F# comme si la fonction renvoyait un tuple.

  7. #47
    Membre éprouvé Avatar de anthyme
    Homme Profil pro
    Inscrit en
    Mars 2004
    Messages
    1 559
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Mars 2004
    Messages : 1 559
    Points : 1 257
    Points
    1 257
    Par défaut
    Citation Envoyé par ijk-ref Voir le message
    Cela se discute. Ma philosophie : ne rien réinventer... ainsi je réutilise toutes la puissance existante des types anonymes
    Bas si tu réinventes bien sur le type de sortie alors pourquoi pas là, c'est quand même bien plus léger d'écrire juste les valeurs que des "clef-valeurs".

    Après pour les généric <(int toto,string tata)> je suis pas fan du tout ...

    En fait mon avis perso ça serait de garder le tuple comme base derrière et de rajouter du sucre syntaxique (un peu comme le linq et ses shortcut)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    public (int, string, bool) Toto()
    {
       return (1, "tutu", true);
    }
    que le compilateur transformerait à la compilation en tuple sans aucuns soucis

  8. #48
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par LLB Voir le message
    Avec F#, tu ne fais pas du Caml, tu fais... du F#.

    Si tu as une fonction C# qui utilise "out", tu peux l'utiliser en F# comme si la fonction renvoyait un tuple.
    Oui et VisualBasic c'est pas du Basic...

    Autrement si tu as un exemple F# pour notre cas

    Citation Envoyé par anthyme Voir le message
    Bas si tu réinventes bien sur le type de sortie alors pourquoi pas là, c'est quand même bien plus léger d'écrire juste les valeurs que des "clef-valeurs".
    Nan je ne le réinvente pas ! A la compilation ces deux lignes sont exactement les mêmes :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    var point  = new Point(3, 4);
    Point point = new Point(3, 4);
    tout comme je le voudrais pour :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    var pair = new {Key = 1, Value = "toto"};
    (int Key, string Value) pair = new {Key = 1, Value = "toto"};
    "Mon" type existe déjà en c# 3 sauf qu'il s'initialise uniquement via "var". J'y rajoute seulement mon écriture pour pouvoir l'utiliser en sortie de méthode.
    Citation Envoyé par anthyme Voir le message
    Après pour les généric <(int toto,string tata)> je suis pas fan du tout ...
    Tu sais "ICollection<(int toto,string tata)>" existe et est déjà utilisé... sauf qu'il est caché dans un "var"
    Citation Envoyé par anthyme Voir le message
    En fait mon avis perso ca serait de garder le tuple comme base derrière et de rajouter du sucre syntaxique (un peu comme le linq et ses shortcut)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    public (int, string, bool) Toto()
    {
       return (1, "tutu", true);
    }
    que le compilateur transformerai à la compilation en tuple sans aucuns soucis
    Alors il n'y a vraiment plus aucun intérêt ! Toutes mon histoire est de pouvoir définir les noms de propriétés. Je m'exprime donc si mal pour que tu passes carrément à coté de ça !?

    Bien que ton "return (1, "tutu", true);" aurait quand même un sens avec "mon" type... mais là on rentre à l'étape 2 de mon raisonnement... et j'avoue j'évite d'en parler car elle apporterait encore plus de questions de non-compréhension de votre part .

    Je ne devrais pas... mais je le dis quand même... en espérant que vous aillez assez d'imagination pour voir le véritable intérêt sur un exemple sans intérêt :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    int i = 0;
    string msg = "toto";
    double value = 3.14;
    pourrait aussi s'écrire comme cela :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    (int i, string msg, double value) = (0, "toto", 3.14);
    ... aussi une sorte d'initialisation en parallèle

  9. #49
    Membre éprouvé Avatar de anthyme
    Homme Profil pro
    Inscrit en
    Mars 2004
    Messages
    1 559
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Mars 2004
    Messages : 1 559
    Points : 1 257
    Points
    1 257
    Par défaut
    Le problème de ta solution c'est que c'est vraiment trop verbeux comparé a ce que cela apporte et pas dans la philosophie du tuple qui sont juste des variables ordonnées.

    Pour le var effectivement cela marche comme ça "derriere" mais perso je me moque de ce qu'il y a derrière ce que je veux c'est un code clean et lisible

    Je proposerai encore plus concis d'ailleurs :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    public (int, string, bool) Toto()
    {
       return 1, "tutu", true;
    }

  10. #50
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par anthyme Voir le message
    Le problème de ta solution c'est que c'est vraiment trop verbeux comparé a ce que cela apporte et pas dans la philosophie du tuple qui sont juste des variables ordonnées.

    (...) ce que je veux c'est un code clean et lisible
    Ta remarque m'étonne d'avantage car... question lisibilité...

    Il est pour ma part plus "lisible" d'avoir des noms de variable qui veulent dire quelque chose. Je pense plutôt que tu fais une confusion entre "lisibilité" et "écriture que tu ne connais pas".

    Sur le long terme mon écriture est bien plus claire et ne sort pas des noms de propriété imposés - ce serait une 1ère dans un compilateur récent !

    De plus super pour le suivi du code ! On ne sait même pas à quoi correspond les variables ordonnées - leur nom sert justement à cela.

  11. #51
    LLB
    LLB est déconnecté
    Membre expérimenté
    Inscrit en
    Mars 2002
    Messages
    967
    Détails du profil
    Informations forums :
    Inscription : Mars 2002
    Messages : 967
    Points : 1 410
    Points
    1 410
    Par défaut
    Imaginons qu'il regarde dans les types qui sont dans les return pour déduire le type à renvoyer et qu'il renvoi le type le plus "général" (si tu as un classe A et une classe B qui hérite toutes les 2 de C, le type déduis de return new A(); et return new B(); serai donc C)

    Je vais te donner un exemple correct (car je suis d'accord que mon ancien exemple qui retournait un int et une string c'est incorrect syntaxiquement) mais où le type est impossible à déduire :
    Cet argument n'est pas pertinent, car il y a le même problème avec "var".

    L'inférence de type locale (var) est facile à implémenter. En revanche, l'inférence de type sur la définition de la fonction est un peu plus complexe, à cause, entre autres, de la récursion. C'est quelque chose qui peut être fait quand c'est conçu dès le départ, au prix de quelques complexités dans le langage (par exemple F#) ou de sérieuses limitations dans le langage (par exemple OCaml). Je ne pense pas que ce sera ajouté à C# (ou alors peut-être seulement dans des cas assez particuliers ?).


    Pour les initialisations en parallèle, ça se fait facilement en F# :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    let a, b, c = "test", 8, 3.2
    Ca marche aussi dans Mono : http://tirania.org/blog/archive/2009/Dec-23.html

  12. #52
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par LLB Voir le message
    Pour les initialisations en parallèle, ça se fait facilement en F# :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    let a, b, c = "test", 8, 3.2
    Vivement la même chose en C#... dans l'intérêt d'avoir une fonction unique (à droite) affectant plusieurs variables.
    Citation Envoyé par LLB Voir le message
    Cool ! Ainsi on peut faire cela en Mono :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    (user, password, host, port, path) = ParseUri (url);
    Pourquoi n'y a-t-il rien de similaire dans la version originale de Microsoft !?

    Question technique : c'est quoi le fichier "tuple.diff" (tuple patch) ?
    Il sert à la compilation du compilateur de Mono ?

  13. #53
    LLB
    LLB est déconnecté
    Membre expérimenté
    Inscrit en
    Mars 2002
    Messages
    967
    Détails du profil
    Informations forums :
    Inscription : Mars 2002
    Messages : 967
    Points : 1 410
    Points
    1 410
    Par défaut
    Citation Envoyé par ijk-ref Voir le message
    Pourquoi n'y a-t-il rien de similaire dans la version originale de Microsoft !?
    Ce n'est qu'une proposition, non standard, pour le moment. À terme, ce sera peut-être ajouté dans le standard (et pas forcément avec cette syntaxe), mais il faudra attendre plusieurs années.

    Sinon, tu peux aussi utiliser F#.
    Citation Envoyé par ijk-ref Voir le message
    Question technique : c'est quoi le fichier "tuple.diff" (tuple patch) ? Il sert à la compilation du compilateur de Mono ?
    C'est la modification du code (dans le compilateur de Mono) qui ajoute cette fonctionnalité. Je pense que ça a été intégré dans le code de Mono et que c'est activable avec l'option -langversion:future (à vérifier). À moins que tu ne veuilles bidouiller leur compilateur, ce diff ne te sera pas très utile.

  14. #54
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par LLB Voir le message
    C'est la modification du code (dans le compilateur de Mono) qui ajoute cette fonctionnalité. Je pense que ça a été intégré dans le code de Mono et que c'est activable avec l'option -langversion:future (à vérifier). À moins que tu ne veuilles bidouiller leur compilateur, ce diff ne te sera pas très utile.
    C'est ce que j'ai cru comprendre... mais j'avais besoin d'une confirmation.
    Citation Envoyé par LLB Voir le message
    Sinon, tu peux aussi utiliser F#.
    J'y songe sérieusement !

  15. #55
    Membre éprouvé Avatar de anthyme
    Homme Profil pro
    Inscrit en
    Mars 2004
    Messages
    1 559
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Mars 2004
    Messages : 1 559
    Points : 1 257
    Points
    1 257
    Par défaut
    Citation Envoyé par LLB Voir le message
    Pour les initialisations en parallèle, ça se fait facilement en F# :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    let a, b, c = "test", 8, 3.2
    Ca marche aussi dans Mono : http://tirania.org/blog/archive/2009/Dec-23.html
    Ah super ça c'est une autre essence du tuple, il va vraiment falloir que je me plonge dans F# !

    Dans le même style en python (créateur du tuple ?) on peut faire ca :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    def Color():
        return 255, 112, 255
     
    r, v ,b = Color()
    Concis et efficace et sans s'encombrer du nommage des variables dans la fonction, top

  16. #56
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par anthyme Voir le message
    (...) Concis et efficace et sans s'encombrer du nommage des variables dans la fonction, top
    Tu vois : tu recommences !

    Si tu aimes particulièrement les langages de script... pouvant être de typage... dynamique fort (certes)... mais non vérifié à la compilation... libre à toi !

    Cependant reprocher à C# ne pas en être... c'est du n'importe quoi ! C'est comme si tu reprochais à l'eau d'être trop mouillé !

  17. #57
    LLB
    LLB est déconnecté
    Membre expérimenté
    Inscrit en
    Mars 2002
    Messages
    967
    Détails du profil
    Informations forums :
    Inscription : Mars 2002
    Messages : 967
    Points : 1 410
    Points
    1 410
    Par défaut
    Citation Envoyé par ijk-ref Voir le message
    Si tu aimes particulièrement les langages de script... pouvant être de typage... dynamique fort (certes)... mais non vérifié à la compilation... libre à toi !
    Code Python (typage dynamique) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    def Color():
        return 255, 112, 255
     
    r, v, b = Color()
    Code F# équivalent (typage statique) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    let Color() = 255, 112, 255
     
    let r, v, b = Color()
    C'est exactement la même longueur ! Pourtant, F# a un typage statique et vérifie autant de choses (en réalité, c'est même plus de choses) que C#, à la compilation. Ce n'est pas parce que Java et C++ sont verbeux que tous les langages à typage statique doivent l'être. Scala est un autre contre-exemple.

  18. #58
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par LLB Voir le message
    C'est exactement la même longueur ! Pourtant, F# a un typage statique et vérifie autant de choses (en réalité, c'est même plus de choses) que C#, à la compilation. Ce n'est pas parce que Java et C++ sont verbeux que tous les langages à typage statique doivent l'être. Scala est un autre contre-exemple.
    Merci !

  19. #59
    Membre éprouvé Avatar de anthyme
    Homme Profil pro
    Inscrit en
    Mars 2004
    Messages
    1 559
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Mars 2004
    Messages : 1 559
    Points : 1 257
    Points
    1 257
    Par défaut
    Citation Envoyé par ijk-ref Voir le message
    Tu vois : tu recommences !

    Si tu aimes particulièrement les langages de script... pouvant être de typage... dynamique fort (certes)... mais non vérifié à la compilation... libre à toi !
    Euhhh je ne vois pas en quoi un langage a typage static empêche d'avoir une écriture concise ! Ma proposition auparavant peut tout a fait marcher avec un typage statique, je ne montrais ici que l'influence de l'écriture d'un langage à typage dynamique. Avoir de bonne idée d'évolution sur un langage c'est bien souvent de retirer ses œillères et de regarder les autres langages qui existent depuis longtemps, c'est ce qu'ont fait les créateurs de C# et c'est ce qu'ils font encore en proposant ce genre d'innovations.
    C# s'inspire de plus en plus de toutes ces subtilités d'écritures des langages dynamiques depuis C#3 et c'est vraiment une bonne chose.

    Citation Envoyé par ijk-ref Voir le message
    Cependant reprocher à C# ne pas en être... c'est du n'importe quoi ! C'est comme si tu reprochais à l'eau d'être trop mouillé !
    Écoute ... D'un merci de ne pas me faire dire des choses que je n'ai pas dit, je n'ai jamais reproché a C# d'etre à typage static (mais j aurai d'autres reproches à faire) je ne fais que, comme toi, faire une proposition syntaxique.
    De deux, tu n'aimes pas ma proposition d'affecter 3 variables à la volée séparé par des virgule et dans le post d'après tu apprécie la notation F# qui est exactement la même, il y a comme une incohérence dans ton propos... Cette syntaxe déjà implémenté depuis un moment dans F# ça montre bien qu'elle du sens autant dans la lisibilité que dans la fonctionnalité.
    De trois, tu as fait une proposition que évidement tu aimes voir défend (avec trop d'ego peut être?) que l'on a tous lu, donné notre avis (et j'étais à la base le plus intéressé par celle ci) et surtout respecté sur ce topic donc maintenant tu n'as pas non plus la science absolu alors merci d'être ouvert et de respecter les propositions des autres plutôt que partir dans des réflexions sarcastiques sans grand intérêt qui ne font pas avancer grand chose.
    Merci.

  20. #60
    Membre éprouvé Avatar de anthyme
    Homme Profil pro
    Inscrit en
    Mars 2004
    Messages
    1 559
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Paris (Île de France)

    Informations forums :
    Inscription : Mars 2004
    Messages : 1 559
    Points : 1 257
    Points
    1 257
    Par défaut
    Citation Envoyé par LLB Voir le message
    Code Python (typage dynamique) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    def Color():
        return 255, 112, 255
     
    r, v, b = Color()
    Code F# équivalent (typage statique) :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    let Color() = 255, 112, 255
     
    let r, v, b = Color()
    C'est exactement la même longueur ! Pourtant, F# a un typage statique et vérifie autant de choses (en réalité, c'est même plus de choses) que C#, à la compilation. Ce n'est pas parce que Java et C++ sont verbeux que tous les langages à typage statique doivent l'être. Scala est un autre contre-exemple.
    Ah mince j'ai fait doublon

    Vraiment sympa la syntaxe F# j'aimerai bien un petit mix entre C# et F#

    Par contre qu'est ce que tu veux dire par "plus de choses" ?

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo