Salut, je fais quelques recherches en ce moment et je me demandais pour ma culture perso : existe-t-il un langage qui permette de manipuler les concepts de classe, type, interface, etc. comme des objets ?
Dans ma tête un tel langage permettrait notamment de créer des classes à la volée pendant l'exécution du code et de les manipuler comme des objets. Ou même de manipuler des classes préalablement définies pour leur ajouter des méthodes ou des propriétés.
Je ne suis pas certain des applications que pourrait avoir un tel langage, mais je me demandais si ça existait.

Et pour poursuivre dans ma recherche de concepts informatiques bizarres, je me demandais aussi si ça existait des "interfaces soustractives" ? En gros, une interface normale permet de définir les méthodes qu'implémente une classe, et une interface soustractive permettrait de définir les méthodes que n'implémente pas une classe. Encore une fois, pas certain de l'intérêt pratique, mais peut-être un intérêt sémantique quand même.

En fait, l'idée que j'ai derrière tout ça, c'est des agents capables de manipuler des classes : dans une simulation multi-agent, un agent pourrait se créer une base de connaissance en se construisant des classes, des types, des interfaces et pourrait manipuler ces éléments.
Par exemple, un agent "conducteur" se balade dans un monde virtuel, il tombe sur une voiture. Evidemment l'agent n'a pas accès aux propriétés/méthodes de la voiture (il n'a accès qu'aux méthodes permettant de manipuler son propre corps), il va donc se construire une classe "voiture" qu'il va garder en mémoire et il va y mettre tout ce qu'il peut supposer sur les propriétés et les méthodes de la voiture après avoir interagi avec la voiture. Toutes les interactions entre l'agent et la voiture qui donnent un résultat pourraient faire l'objet d'une méthode dans cette classe "voiture". Et si dans la classe construite par l'agent il y a la méthode "accélérer", alors l'agent pourra utiliser par la suite cette méthode "accélérer" pour faire avancer la voiture. Cette méthode "accélérer" aura été défini par l'agent pour décrire la voiture : dans le corps de cette méthode il serait spécifié "j'appuie sur la pédale à droite dans la voiture".
Maintenant, mettons que la voiture ne roule plus, alors l'agent pourra créer l'interface soustractive "en panne" qui spécifie qu'une voiture n'implémente pas la méthode "accélérer".

Quelqu'un connaîtrait un langage ou même une bibliothèque qui permettrait ça ?

moralement, tu peux faire ca en n'importe quoi qui supporte le linkage dynamique. En C++, il "suffit" d'ecrire un fichier qui contient le code de ta classe comme il faut, puis tu la compile dans une lib dynamique et tu l'ouvre comme un shared object (dlopen sous linux).

Mias j'ai l'impression que ce que tu veux c'est un truc plus generique...

En passant, j'ai pas compris en quoi ca servait a qqch...

Moi non plus je ne comprends pas trop où tu veux en venir alors je vais essayer de répondre point par point.

De mémoire JAVA permet de surcharger une méthode à la volée et cglib permet d'étendre des interfaces et des classes entièrement au runtime http://cglib.sourceforge.net/

Pour les interfaces soustractives pas très sûr d'avoir bien compris mais concrètement ça revient tout simplement à la même chose que mettre une méthode en private non ?

La plupart des langages basés sur Smalltalk.

Par contre, c'est généralement des langages interprétés (et non compilés).

"En passant, j'ai pas compris en quoi ca servait a qqch..."

Je m'en doutais
Moi même je ne sais pas si c'est bien utile et s'il y a un moyen plus simple de faire ce que je veux faire : à savoir, des agents qui infèrent des concepts à partir de leurs perceptions au sein d'une simulation multi-agent. Et pour faire ça j'ai pensé que ça pouvait être pas mal que ces agents soient capables de définir des classes (car un concept n'est rien d'autre qu'une classe).
On pourrait aussi voir ça comme des agents qui essayent de construire une ontologie pour comprendre le monde virtuel dans lequel ils évoluent, à quelques différences près, notamment la possibilité de se définir des méthodes.

"Pour les interfaces soustractives pas très sûr d'avoir bien compris mais concrètement ça revient tout simplement à la même chose que mettre une méthode en private non ? "

L'idée c'est que tu as une classe "Voiture" qui possède la méthode "rouler". En disant "Voiture implements EnPanne", tu crées une voiture qui n'implémente pas la méthode "rouler". Aucun intérêt pratique en terme de programmation, mais ça pourrait avoir un intérêt au niveau sémantique lorsque des agents se doivent se construire une base de connaissance.
M'enfin, l'interface soustractive c'est une idée que j'avais eu comme ça mais c'est pas franchement important.

"La plupart des langages basés sur Smalltalk.

Par contre, c'est généralement des langages interprétés (et non compilés)."

Ok Je vais regarder de ce côté là, je m'attendais bien à ce qu'un langage de ce genre soit interprété plutôt que compilé.

Je pense qu'en Java tu peux faire tout ce que tu as décris.

Concernant les interfaces soustractives, j'émets un petit bémol par contre, mais pense que c'est possible de le faire avec des annotations.

en ruby ou tout est objet, les classes n'échappent pas a la règle. Tu peux déclarer a la volée de nouvelles méthodes, de nouveaux paramètres et bien entendu de nouvelles classes.

http://viewsourcecode.org/why/hacking/seeingMetaclassesClearly.html

JS permet un peu ça, mais on parle de pseudo classe.

On appelle ces manipulations la réflexivité ou réflexion: http://fr.wikipedia.org/wiki/R%C3%A9flexivit%C3%A9_%28informatique%29

Pour les cas pratiques, c'est utile quand il faut exécuter du code écrit dynamiquement par les utilisateurs d'une application, de pouvoir déterminer la classe d'une instance de type "Object" (cas le plus fréquent d'utilisation de réfléxivité il me semble), de modifier le comportement de classes et de méthodes alors que l'on ne peut/veut pas modifier le code original (ex: chronométrer des temps d'exécution de méthodes sans modifier le code de l'application originale)...

En pratique il est déconseillé d'utiliser cette technique comme c'est une source d'ennuis supplémentaires qu'on peut généralement éviter (ex: créer une instance d'une classe dont on n'est même pas sûr au moment de l'exécution qu'elle existe ou qu'on lui a donné le nom correct alors que c'est normalement contrôlé à la compilation).

Pourquoi vouloir manipuler des classes comme des objets?

Si tu décides que la classe Voiture implémente enPanne, dans ce cas, tous les objets Voiture que tu créeras seront en panne et non un seul objet. A moins de considérer que cette classe soit un singleton et qu'il n'y ait qu'une voiture dans le monde.

Si tu veux que ce soit propre à une seul voiture, les attributs sont là pour ça. Rien ne t'empêche de tester si la voiture est en panne dans la méthode accélérer.

Après, si ton but est justement de rendre toutes les voitures du monde en panne, tu peux manipuler les classes comme des objets en utilisant des méthodes et attributs statiques.
Il te suffit alors, dans la méthode d'instance accélérer de vérifier l'attribut statique enPanne qui lui, a une portée sur toutes les voitures.

Donc je ne vois vraiment pas l'intérêt des classes soustractives. En plus ça poserait des problèmes de compilation pour l'appel de fonction dans des langages de typage fort comme le Java.

Comme je le disais plus tôt, tu peux manipuler tes classes comme des objets avec des attributs statiques.