lovelydear a écrit 4 commentaires

En D, la concaténation de chaîne est encore bcp plus simple: "Hello"~" world"

Ce sont des langages système, donc de bas niveau.

Si vous voulez les fonctionnalités de Python ou de Matlab, faites du Python ou du Matlab. Les langages C/C++/D ne sont pas faits pour manipuler des vecteurs (au sens mathématique), il sont faits pour manipuler des éléments en mémoire.

Le D est nettement plus lisible que le C++.
Sinon, pour l'exemple ci-dessus, il n'a rien d'effrayant, vous pouvez parfaitement en faire une fonction moyenne, et vous remarquerez que vous pouvez définir une fonction intégrale de la même manière:

auto integrale = integrate!("sin(x)")(0, Pi);

A part le '!', difficile de faire plus simple.

Est-ce que tu pourrais en dire un peu plus sur la signification de alias pred, et pourquoi tu utilises un compile-time test plutôt que de spécifier un type du style delegate bool(T)?

L'exemple est tiré de "The D Programming Language" d'A. Alexandrescu. Vous avez raison, delegate bool(T) est plus simple ici, mais c'est juste à titre d'exemple. Mais imaginons une fonction find42 qui cherche la string '42'.

T[] find42(alias pred, T)(T[] input)
    if (is(typeof(pred(input[0])) == string)
{
  // on raccourcit le tableau d'un elem, ce qui revient à avancer le pointeur *input
  for(; input.length > 0; input = input[1..$]){
    if (pred(input[0]) == '42') break; // si le prédicat vaut '42', on s'arrête
  }
  return input;
}

alias nom synonyme; où nom peut être n'importe quel symbole compilable, ça peut être une fonction, un type, une valeur, un nom de module…
Dans find42, alias pred peut être un delegate string(T), mais aussi une string, par exemple.
Les contraintes if peuvent bien sûr être nettement plus complexes et porter sur les divers paramètres du template.

À mon humble avis il y a déjà assez de langages satisfaisants à l'implémentation libre pour qu'on n'ait pas besoin de jeter son dévolu sur un langage au statut moins clair. Par exemple, si j'étais intéressé par le genre de choses que met D en avant, je pourrais à la place utiliser et soutenir Rust (aussi en développement), ATS (un peu plus orienté recherche), Cyclone (un peu mort), Vala ou même Common Lisp (SBCL) ou OCaml.

Le gros avantage de D, outre la syntaxe relativement familière pour les habitués de C++ est son rapport expressivité/performance. ATS a l'air intéressant, mais ne semble maintenu que par une personne. D a maintenant une dizaine de contributeurs très réguliers et une trentaine de contributeurs occasionnels. C'est sans compter les mainteneurs des compilateurs alternatifs. Il y a en moyenne 5 bugs corrigés/jour, sans compter les nouveaux développements. Comme il est développé par des experts du C++ (W. Bright et A. Alexandrescu), ce langage et ses pratiquants sont clairement la cible. Par conséquent, la performance fait partie des buts essentiels.

Bonjour,

Je suis d'accord sur le fait que cette présentation n'est pas très réussie, elle passe du temps sur des trucs qui ne font pas l'intérêt du langage (comme les boucles ou les classes), tant en délaissant quantité de choses bien plus intéressantes. Il y en a de bien meilleures sur le net si vous êtes anglophone. Pour ma part, je considère que D est l'un des langages natifs les plus puissants actuellement (si ce n'est LE langage natif le plus puissant).

Pour ce qui est des delegates, voici un exemple plus intéressant:

// find est une fonction template qui prend un delegate en predicat
// le if(is(typeof...)) est une condition sur le prédicat vérifiée par le compilateur
// celui-ci doit retourner un bool
// input[1..$] dénote le tableau input[i] pour i = 1 .. length-1

T[] find(alias pred, T)(T[] input)
    if (is(typeof(pred(input[0])) == bool)
{
  // on raccourcit le tableau d'un elem, ce qui revient à avancer le pointeur *input
  for(; input.length > 0; input = input[1..$]){
    if (pred(input[0])) break; // si le prédicat est vérifié, on s'arrête
  }
  return input;
}

// exemple d'usage
unittest{
  int[] a = [1, 2, 3, 4, -5, 3, -4];
  // trouve le premier nombre < 0
  auto b = find!(delegate bool(int x){return x < 0;})(a);
  // idem, notation raccourcie qui tire parti de l'inférence de type
  auto b = find!((x){return x < 0;})(a);
}

Vous voyez dans l'exemple ci-dessus plusieurs notions de D: les templates, les contraintes de signature, les fonctions d'ordre supérieur, et l'inférence de type. C'est la combinaison de toutes les features de D qui en font sa puissance.

Enfin je suis amusé par une légère forme de langue de bois en fin de dépêche. Tu dis que le langage "n'est pas propriétaire" (je ne sais pas exactement ce que ça veut dire) mais le paquet conseillé pour Debian est "dmd", un compilo qui est justement propriétaire. Je note aussi que si on va sur la page officielle du langage et qu'on clique sur "téléchargement", on ne se voit proposer que celui-là; c'est bien qu'il existe des implémentations libres à côté mais encore faut-il qu'elles soient à jour, compétitives et utilisées, ce qui reste à prouver. Bref il me semble un peu optimiste (voire autruche) de classer cette remarquer dans la catégorie "mythes et légendes fausses".

C'est inexact. La licence du backend du compilo DMD est propriétaire, mais le frontend est complètement open source. Et on peut contribuer au backend à volonté. La seule chose qui est interdite par la licence, c'est de redistribuer le backend.

Le source est sur Github
Quand aux autres compilos, si LDC (LLVM) est fortement en retard, LDC (gcc) est en etard de 2 versions, soit environ 4 mois, sur DMD. Il est parfaitement utilisable et utilisé en pratique.