lisibilité

1)
Character -> String


Soit :
   Char : Character;
   procedure Proc (P : String);

Y a-t-il une différence entre :
    Proc ((1 => Char));
    Proc (Char & "");
?

J'ai vu plusieurs fois la 1ère forme, jamais la 2ème.
Est-ce un hasard, ou est-ce qu'il y a une raison particulière ?
(Par exemple est-elle considérée comme plus lisible ?)



2)
Associations de paramètres nommées (Est-ce que je traduis correctement ?)


Je vois énormément d'associations de paramètres nommées,
et j'ai tendance à trouver ça ennuyeux, notamment je trouve que ça prend beaucoup de place,
parce que je n'arrive pas à saisir l'intérêt réel.

Du coup, j'ai naturellement tendance à les remplacer par la classique association de paramètres positionnelle.

Est-ce que je fais bien, ou est-ce qu'il y a un intérêt réel que je perd quand je les remplace ?

Est-ce que quelqu'un pourrait m'expliquer svp ?
À moins que vous soyez plutôt de mon avis ?



3)
Notation pointée


Le 4 nov. 2021 à 05:31, Thomas De Contes via Ada-france a écrit :

> La notation pointée n'est accessible pour appeler des sous-programmes qu'avec les types taggés. Pourquoi ?
> 
> Je viens de m'apercevoir de son coté pratique,
> et je ne comprend pas ce qu'il peut y avoir comme inconvénient à étendre ça aux types non-taggés, puisque c'est en gros seulement une affaire de visibilité, je ne vois rien comme mécanisme qui soit spécifique aux tags.

Je crois deviner qu'il y a des cas, quand le type n'est pas connu à la compilation, où le gain en choisissant la notation pointée est encore plus grand.
Mais ça ne retire rien au fait qu'avec les types non-taggés, on aurais quand même un gain ...

> Y a-t-il une bonne raison qui fait qu'on ne peut pas espérer l'avoir dans une future version du langage ?

Si non, est-ce que vous êtes d'accord avec moi, ou est-ce que vous trouvez que ça ne sert à rien ?

- Pas de clause "use" qui rend trop de choses visibles,
- on doit indiquer le nom du paquetage complet seulement au moment de déclarer la variable, plus quand on s'en sert (sinon, sans clause "use" on doit l'indiquer à nouveau à chaque appel de sous programme),
- le type de la variable est suffisant pour qu'il n'y ait aucune ambiguité possible, dans aucune situation (il me semble).


> Avez vous un avis sur ce que j'ai de mieux à faire, pour faire le meilleur code possible ?
> - Supprimer l'aspect "taggé", parce que pas besoin des tags ?
> - Conserver l'aspect "taggé", parce que l'avantage de la notation pointée est suffisant pour le justifier ?

Pour le cas que j'avais, j'ai décidé de supprimer le tag.

Par contre, j'ai un autre cas dans lequel je souhaite que la variable soit la plus discrète possible (et actuellement elle est très discrète, puisqu'elle est globale !).
J'avais pensé qu'avec la notation pointée elle se fondrait dans le nom de la procédure, au lieu d'être ajoutée aux paramètres.

C'est pour ça que je vous re-pose la question :
À votre avis, quand on veut faire du code propre,
tagger un type quand on n'a pas besoin du tag mais qu'on veut seulement utiliser la notation pointée,
est-ce que c'est possible de le faire en gardant son code assez propre, ou est-ce que ça le "salit" immédiatement ?



> Un peu de la même façon, ça serais chouette de pouvoir remplacer
>    Ada.Strings.Unbounded.To_String (Window.FileName)
> par
>    Window.FileName.To_String


> Y a-t-il un équivalent pour les constructeurs ?
> 
> Si non, le petit inconvénient que donnerais la notation pointée appliquée à Unbounded_String serait l'asymétrie dans l'écriture entre To_String et To_Unbounded_String.

Pour ce dernier point, pas de problème : Set_Unbounded_String fait l'affaire dans la plupart des cas.


-- 
RAPID maintainer
http://savannah.nongnu.org/projects/rapid/

_______________________________________________
Ada-france mailing list
[email protected]
https://mail.ada-france.org/cgi-bin/mailman/listinfo/ada-france