PureBasic

Avec EnableExplicit, il faut procéder ainsi : Mais le code qui suit me semble tout aussi rigoureux : Serait-il possible d’étendre de la sorte les facultés de EnableExplicit ?

çà m'étonnerais dräc étant donné que c'est bel et bien le but de EnableExplicit de forcer le programmeur à declarer toutes ses variables. Le plus simple est encore de faire comme çà:

Déclarer une variable c'est la nommée et lui donner un type.
Si on est d'accord sur cette définition, je ne vois pas en quoi il n'y aurait pas stricte équivalent entre les deux codes!!

Disons que je propose à PB de donner l'équivalence entre: et En effet, qu'apporte le mot clef Define dans ce cas...

En fait EnableExplicit oblige à déclarer avec Define, Shared, Protected, Dim, Newlist ou en argument

Grossomodo derrière un mot clé "déclarant"

Dri

Je l'attendais depuis longtemps ce EnableExplicit

Maintenant, je ne travaille qu'avec

1- Le problème n’est pas de remettre en cause le bénéfice de ‘EnableExplicit’ qui est incontestable.
D’ailleurs je faisais, moi aussi, partie des gens qui l’attendait.

Mais quel est le but de EnableExplicit si ce n’est celui d’obliger le programmeur à expliciter la déclaration de toutes ses variables de son code afin que le compilateur n’est pas à supposer le type et qu’il n’y est pas d’ambiguïté.

J’estime donc que d’écrire
Ou possède les vertus nécessaires et suffisantes d’une déclaration explicite.

Si vous prenez séparément l’une de ces deux lignes, vous comprenez bien la même chose : Il s’agit de déclarer une variable nommée ‘a’ de type long.

2- Le sujet n’est pas non plus celui de comprendre pourquoi il faut utiliser ‘Define’ (le choix du concepteur est ainsi) mais plutot de demander s'il est interessant/pertinent d'élargir le potentiel de ‘EnableExplicit’ ?

Conclusion
Si vous m’avez suivit depuis le début, ma demande est tout simplement la suivante et elle me semble toujours légitime:

Que le mot clé ‘EnableExplicit’ reconnaisse que l’écriture à la volée ‘a.l’ est une déclaration explicite et qu’il l’autorise.

Ca été discuté et apparement y'a des personnes qui utilise le suffixe du type tout le temps pour bien se rappeler de quel type est telle ou telle variable. Dans ce cas, EnableExplicit aurait été inutile car le type est spécifié à chaque fois.

J'avoue ne pas vraiment saisir la réponse: il est clair que de répéter le type d’une variable à chaque fois ne peut être qu’explicite !

Donc très bien si les gens sur-exploitent le suffixe du type.
Mais quel est le soucis du compilo dans ce cas ?
Je suppose que lorsque ‘EnableExplicit’ n’est pas utilisé, le compilo attribut à une variable le premier type rencontré et ignore, si ce n’est pour avertir d’une incohérence de type, toutes les autres occurrences explicites.

Répéter le type d’une variable à chaque fois n'est pas un soucis en soit.


Or,je le répète, ce n’est pas ‘EnableExplicit’ le problème, mais ‘Define’
Je me place bien dans le cadre de l'utilisation de ‘EnableExplicit’

Ce que je propose, c’est une application plus pragmatique/souple de l'explicitation de types:

Expliciter le type d’une variable au moins une fois, sans forcement utiliser ‘Define’ (et pouvoir s’affranchir par la suite de re-typer la variable).

Bref, c’est ainsi que mes codes sont construits, mais je n’ai pas de moyen simple pour vérifier que j’ai explicité au moins une fois chaque variable.
Dés que je désire utiliser ‘EnableExplicit’, je suis obligé d’opérer des modifications fastidieuses de toutes mes déclarations de variables pour une petite poignée de variables qui ne seront effectivement pas explicitées.


D’où ma question :
Pourquoi ne pas avoir l’équivalence et lorsque ‘EnableExplicit’ est utilisé

Quel est le problème technique, si personne n’y voit de problème sémantique ?