Les types

           

• Maple est un langage typé.
• Les types dans Maple tiennent beaucoup des langages orientés objet.
• Toutes les données sont typées hiérarchiquement. Par exemple:

       type(5,nonnegint);   -> true
       type(5,integer);     -> true
       type(5,posint);      -> true
       type(5,numeric);     -> true
       type(5,constant);    -> true

• On obtient la liste de tous les types avec ?type. On obtient une explication détaillée avec par exemple ?type,nonnegint.
• Les types servent à vérifier que les arguments passés à une procédure sont du type attendu. Toutefois le typage n'est pas obligatoire. Par exemple, les deux procédures suivantes sont strictement équivalentes du point de vue de l'utilisateur:

       fact1 := proc(n) 
       option remember;
       if type(n,posint) then
          if n=1 then 1 else n*fact1(n-1) fi;
       else ERROR(`Wrong type`);
       fi;
       end;

       fact2 := proc(n:posint) 
       option remember;
          if n=1 then 1 else n*fact2(n-1) fi;
       end;

•             Pour vérifier le typage, 3 fonctions sont disponibles: type(expr,_type), whattype(expr) et hastype(expr,_type). whattype() renvoie une chaîne de caractère qui correspond au type basique auquel s'identifie l'expression. type(expr,_type) et hastype(expr,_type) sont des fonctions booléennes qui permettent de vérifier des types complexes.

    g:= 3*x^2 + 2*x - 1;
    type(g,polynom);             ->  true
    whattype(g);                 ->  +
    type(g,polynom(integer));    ->  true

• Créer un type foo est équivalent à créer une procédure `type/foo`(expr) qui renvoie true ou false. Malheureusement whattype() n'est pas redéfinissable.

  En fait, on distingue deux familles de types pour les utilisateurs:

     
  • les types procéduraux:

    `type/int100` := proc(f) evalb(type(f,nonnegint) and f<100) end;

  • les types structurés: (ou par pattern matching)

    `type/power` := anything^integer;