Les types abstraits introduisent la notion de méthodologie objet dans les algorithmes.

Un type abstrait est constitué de plusieurs constantes, variables et méthodes (fonctions ou procédures) dont certaines constituent une interface par laquelle un objet pourra être manipulé sans pour autant connaître sa mise en oeuvre (ou implémentation).

# Création d'un type abstrait #
type abstrait : identificateur
  interface
  # Déclaration des méthodes #
  {fonction* | proc} nom_méthode([arguments]){: type*};
  ...
  {fonction* | proc} nom_méthodeN([arguments]){: type*};

  représentation
  # Déclaration des variables et constantes #
  {var | const} nom : type;
  ...
  {var | const} nomN : type;

  algorithmes
  # Définitions des méthodes #
  {fonction* | proc} nom_méthode([arguments]){: type*};
      ...
  début
      ...
  fin
  ...
  {fonction* | proc} nom_méthodeN([arguments]){: type*};
      ...
  début
      ...
  fin

ftypeabstrait

# Création d'un objet #
var identificateur_objet : identificateur_type_abstrait;

# Utilisation des méthodes #
identificateur_objet.nom_méthode([arguments]);

# Utilisation des variables et constantes # Une variable ou une constante déclarée dans représentation peut être accédé dans toutes les méthodes du type abstrait.
Les variables peuvent également être modifiées à partir du bloc d'instructions de ces mêmes méthodes.

# Exemple #
type abstrait : Calculatrice
  interface
  proc saisie(res valA, valB : réel, valOP : opération);
  proc calcul(val valA, valB : réel, valOP : opération, res resultat: réel);
  proc affichage(val valA, valB, resultat : réel, valOP : opération);

  représentation
  type opération : énumération : ('+','-','*','/');
  var valA, valB : réel, valOP : opération

  algorithmes
  proc saisie();
  début
      écrire("Entrez un calcul simple 
                     [Nombre, (+ | - | * | /), Nombre (ex.:10.2, *, 5)] :");
      lire(valA, valOP, valB);
  fproc

  proc calcul(res result: réel);
  début
      choix
        type_calcul = '+' -> cas
        result := addition(valA, valB);
        fcas
        type_calcul = '-' -> cas
        result := soustraction(valA, valB);
        fcas
        type_calcul = '*' -> cas
        result := multiplication(valA, valB);
        fcas
        type_calcul = '/' -> cas
        result := division(valA, valB);
        fcas
      fchoix
  fproc

  proc affichage(val result : réel);
  début
      écrire("Opération : ", valA, " ", valOP, " ", valB, " = ", result);
  fproc

  fonction addition(val a, b) : réel;
  début
      résultat (a + b);
  ffonction

  fonction soustraction(val a, b) : réel;
  début
      résultat (a - b);
  ffonction

  fonction multiplication(val a, b) : réel;
  début
      résultat (a * b);
  ffonction

  fonction division(val a, b) : réel;
  début
      résultat (a / b);
  ffonction
ftypeabstrait

algorithme
  var calc : Calculatrice;
         valeur_resultat : réel;
début
  calc.saisie();
  calc.calcul(valeur_resultat);
  calc.affichage(valeur_resultat);
fin