Classes

OpenScheme reconnaît deux types de classes :

• Les classes virtuelles sont définies au-dessus des objets standard du langage Scheme, comme les entiers ou les procédures. Elles identifient les objets leur appartenant à l'aide d'une fonction prédicat donnée lors de la définition de la classe virtuelle, comme la fonction Scheme integer? ou procedure?.

• Les classes construites par l'utilisateur sont explicitement définies en donnant la liste des champs qui les composent et leurs propriétés.

Classes prédéfinies

Le système possède un certain nombre de classes prédéfinies. Ces classes sont calquées sur les objets Scheme comme les entiers ou les procédures.

On trouve les classes prédéfinies suivantes :

Classe	Signification
	Classes ancêtres de toutes les classes.
	Classe des classes. Le moteur objet est méta circulaire.

Les autres classes sont directement connectées aux objets Scheme :

Classe	Ancêtre	Prédicat	Signification
>		boolean?	Booléens #f ou #t.
		symbol?	Symboles Scheme.
		char?	Caractères.
		pair?	Paires.
		string?	Chaînes.
		procedure?	Fonctions.
		vectort?	Vecteurs.
		number?	Nombres.
		complex?	Nombres complexes.
		real?	Nombres réels.
		rational?	Nombres rationnels.
		integer?	Nombres entiers.
		port?	Ports d'entrée/sortie.
		input-port?	Port d'entrée.
		output-port?	Port de sortie.
		input-string?	Chaine d'entrée.
		output-string?	Chaine en sortie.

Ainsi, les objets standard de Scheme appartiennent tous à une classe du moteur objet. Les classes et sont définies pour rendre le moteur méta-circulaire. Dans un système à objets méta-circulaire, une classe est une instance de l'objet des classes.

Pour créer un objet appartenant à ces classes primitives (mise à part et ), il suffit de les écrire : ainsi, l'écriture Scheme 123 crée un objet Scheme ENTIER mais aussi un objet du moteur objet appartenant à la classe .

Les classes reposant sur des objets du langage Scheme sont appelées classes virtuelles, dans le sens ou elles ne sont pas explicitement construites. Elles reposent sur les prédicats associés aux objets : ainsi, la classe repose sur le prédicat integer?. De cette manière, il est possible de créer autant de classes d'objets qu'il y a de prédicats.


Prédicat de classe

Lorsqu'une classe est définie, une fonction prédicat est aussi créer en utilisant le nom de la classe suivie d'un point d'interrogation. Cette fonction a un argument et retourne vrai (#t) si s'il appartient à cette classe et faux (#f) dans le cas contraire.

Par exemple, si la classe est définie, la fonction est aussi définie. Elle retourne vrai si l'objet en argument appartient à la classe et faux sinon.

Ainsi, il est possible écrire :

Osm> <integer>
  => #class

Osm> (<integer>? 123)
  => #t

Osm> (<integer>? 123.456)
  => #t

Un objet appartient à une classe et aussi aux classe ancêtres. Ainsi :

Osm> (<integer>? 123)
  => #t

Osm> (<real>? 123)
  => #t

Ce dernier résultat et obtenu car la classe est un ancêtre de la classe , comme on peut le lire dans le tableau des classes virtuelles.

Autres fonctions

D'autres fonctions utilitaires permettent de manipuler les objets :

• (is-a? objet classe) : retourne vrai si objet appartient à classe et faux sinon.

• (super? classe-1 classe-2) : retourne vrai si la classe classe-1 est ancêtre de la classe classe-2 et faux sinon.

• (class-of objet) : retourne la classe de l'objet objet. La classe de l'objet est elle-même un objet, représenté sous la forme d'un vecteur.

• (class-name classe) : retourne le nom de classe, sous la forme d'un symbole Scheme et faux sinon.

Ainsi, on peut écrire :

Osm> (is-a?.123 <real>)
  => #t

Osm> (super?.<integer> <port>)
  => #f

Osm> (class-name (class-of 123))
  => <integer>