Premiers pas avec PURE

I -Caractéristiques

Pure est un langage informatique créé en 2008 par Albert Gräf. Successeur du langage équationnel Q, il emprunte des idées d’autres langages fonctionnels tels que Haskell, Miranda et Alice ML.

C’est un langage :

• fonctionnel, basé sur la réécriture de termes :
  L’interpréteur Pure applique des équations spécifiées par le programmeur en tant que règle de réécriture des termes jusqu’à atteindre une expression qui ne peut plus être simplifiée faute de règle de réécriture à pouvoir lui appliquer. On obtient alors une expression appelée forme normale qui est la valeur du terme initial. Par exemple :

> // règle de réécriture
> a * c + b * c = (a + b) * c;
> // réécriture et obtention de la valeur de a * 2 + b * 2
> a * 2 + b * 2;  
 (a + b) * 2

Les termes symboliques comme sum par exemple découlent eux aussi de la réécriture de termes. En Pure, les expressions sont les objets de première classe, les termes symboliques sont donc aussi évaluables.

 > sum [a,b,c]; 
  a+(b+(c+0))

• flexible et libre :
  La réécriture de terme offre au codeur la possibilité de redéfinir les opérateurs du langage. Par exemple, on peut redéfinir l’opérateur de création de liste ‘:’ afin de ne créer que des listes triées et sans doublons :

> // xs est une liste à laquelle on ajoute les éléments y et x
> x:y:xs = y:x:xs if x>y; x:y:xs = x:xs if x==y;
> [13,7,9,7,1]+[1,9,7,5];
[1,5,7,9,13]

• d’évaluation paresseuse, dynamiquement typé :
  Une fonction n’est évaluée que si sa valeur de retour est nécessaire pour évaluer un autre résultat.
  De plus avant de s’exécuter, votre code source ne passe pas par une phase de vérification des types, la vérification se fait au moment où les opérations sont effectuées.
• puissant, caractérisé par le polymorphisme :
  En apparence, Pure ressemble aux autres languages fonctionnels mais en tant que language dynamiquement typé, il est possible d’ajouter une définition à une fonction à tout moment. Ainsi, une même fonction peut traiter des arguments de différents types, sa définition peut aussi être affinée à tout moment.

On parle de polymorphisme paramétrique lorsqu’une fonction peut prendre des arguments de tout type. Une telle fonction n’est définie qu’une fois.

> //définition unique de square
> square x = x*x;
> square 7;
  49
> square 7.0;
  49.0
> square (a+b);
  (a+b)*(a+b)

On parle de polymorphisme ad hoc lorsqu’une fonction est définie différemment selon le type de l’argument passé en paramètre. Une telle fonction peut être redéfinie à tout moment

> // définition de square pour un int 
> square x::int = x*x;
> square 7;
49
> // définition de square affinée pour un double
> square x::double = x*x;
> show square
square x::int = x*x;
square x::double = x*x;
> square 7; square 7.0;
49
49.0
> // définition affinée pour une matrice 2*2
> square {a,b;c,d} = {a*a+b*c,a*b+b*d;c*a+d*c,c*b+d*d};

Pure est plutôt destiné aux applications mathématiques et au calcul scientifique mais offre de par la possibilité d’interfaçage sur le C et l’ensemble croissant de modules supplémentaires, des possibilités d’applications dans divers domaines tels que les graphiques, le multimédia, la programmation système, le web, l’intelligence artificielle , le calcul symbolique…

II -Interpréteur et compilation

Pour commencer, vous allez devoir installer pure. Pour lancer l’interpréteur, tapez la commande ‘ pure ‘ sur la ligne de commande du shell. L’interpréteur affiche alors un message de connexion suivi de sa commande ‘ > ’

Vous pouvez commencer à taper des expressions basiques :

> 17/12 + 23;
  24.4166666666667

En pure les programmes s’exécutent vite car ils sont compilés directement en code natif. Vous pouvez exécuter vos scripts avec la commande “pure” :

> $ pure myscript.pure

Il est possible de rajouter des paramètres de ligne de commande au script avec la variable argv :

> $ pure myscript.pure foo bar baz

Pour lire la documentation en ligne :

> help

Pour quitter l’interpréteur :

> quit (ou CTRL -D)

III -Types

Le tableau ci-dessous présente les différents types du langage Pure :

source : github

IV -Listes, matrices, tuples et enregistrements

Les listes

• [] désigne la liste vide. Les listes peuvent être imbriquées et/ou polymorphes c’est à dire contenir des éléments de différents types : [1[4,3], toto 8 6]
• x:y : Ajoute un élément x en tête de la liste y.
  Ainsi, créer la liste [1,2,3] revient à rajouter successivement les éléments 3 puis 2 puis 1 en tête d’une liste vide 1: 2: 3: []
• x..y : Construit des séquences arithmétiques. x:y..z peut être utilisé pour désigner des séquences avec un pas arbitraire yx . On peut également créer des séquences infinies en utilisant « inf » ou « -inf ».
  1:3..inf est la liste paresseuse de tous les entiers impairs positifs.
• #x : Indique la taille de la liste
• x!y : Permet d’indexer une liste. En Pure, tous les indices commencent à 0.
• x!0 désigne le premier élément d’une liste x
• x!(#x-1) désigne le dernier élément d’une liste x

Pour d’autre fonctions, vous pouvez vous référer au manuel de la bibliothèque Pure .

Les matrices

• La matrice vide est notée {}. La syntaxe est la même que sur MATLAB :
  {1,2,3} désigne un vecteur de ligne
  {1; 2; 3} désigne un vecteur colonne
  {1,2,3; 4,5,6} et {{1; 4}, {2; 5}, {3; 6}} désignent la même matrice 2 × 3.
• #x : Indique la taille de la matrice.
• x!y : Permet d’indexer une matrice. L’indice peut être une paire d’indices de ligne et de colonne.
• Pure supporte également les matrices symboliques qui peuvent contenir n’importe quel mélange de types telles que {1, [2,3], toto, 5} .
• x!(1,2) désigne l’élément de la ligne 1 et de la colonne 2 de la matrice x

Les tuples

Ce sont des structures de données de liste utilisées pour agréger des valeurs à des fonctions ou les renvoyer en tant que résultats. Ils sont construits en utilisant le constructeur de paire associative ‘ , ‘ et le tuple vide () . Par exemple :

> // création du tuple contenant 3 éléments
> 3,2,1,()
1,2,3

> // utilisation d'un tuple en paramètre d'une fonction
> rot2 (x,y,xs) = xs,x,y;
> rot2 (1,2,3,4,5);
3,4,5,1,2

Les enregistrements

• Ce sont des vecteurs symboliques constitués de paires de hachages de la forme clé => valeur. Les clés peuvent être des symboles ou des chaînes.

Par exemple, {x => 3, y => 8} indique une valeur d’enregistrement avec deux champs x et y liés respectivement aux valeurs 3 et 8.

• Les valeurs de champ peuvent être de n’importe quel type. Les enregistrements peuvent être imbriqués, comme dans :
  {x => 3, y => {d => “toto, y => 8}} .

V -Fonctions

• fx désigne l’application d’une fonction f à l’argument x. L’application est associée à gauche c’est-à dire que f xy = ( fx ) y. Ce style d’écriture d’applications de fonction est également connu sous le nom de currying, d’après le logicien américain Curry qui a popularisé son utilisation à travers son travail sur le calcul combinatoire.
• Le Currying est aussi un moyen de transformer l’applications d’une fonction à plusieurs arguments en une série d’applications. Par exemple si f est une fonction prenant deux arguments x et y, alors fx devient une fonction à part entière qui met en correspondance chaque y donné à f xy. Le Currying permet d’obtenir de nouvelles fonctions à partir de celles existantes en omettant les arguments de queue.
• Les applications de fonction sont évaluées de gauche à droite dans Pure, en prioritisant l’intérieur des expressions. On parle d’ordre applicatif ou d’appel par valeur, puisque les objets d’une fonction ainsi que l’objet fonction lui-même sont évalués avant que la fonction ne soit appliquée. Par exemple, considérons la fonction carré:

> square x = x * x;
/*
l’évaluation du carré de l’expression (4 + 3) +1 se déroule comme suit :
square (4 + 3) +1 = square 7 + 1 = 7 * 7 + 1 = 49 + 1 = 50
*/
> square (4 + 3) +1;
  50

Liens utiles :

Installer Pure
Installer l’interpréteur Pure
Utiliser l’interpréteur Pure
documentation complète en ligne
Pure Quick Reference

Références :

https://agraef.github.io/pure-lang/quickref/pure-quickref.pdf

https://agraef.github.io/pure-docs/pure.html#examples

https://code.google.com/archive/p/pure-lang/wikis

https://archive.is/rwUqQ