new version

these-mickael/main.tex

@@ -122,7 +122,7 @@ l'implantation du langage CDuce \cite{}.
 
 
 
-Le but the cette thèse est d'arriver à définir et étudier un langage de programmation fonctionnel statiquement typé qui combine les characteristiques avancée suivantes:
+Le but de cette thèse est d'arriver à définir et étudier un langage de programmation fonctionnel statiquement typé qui combine les caractéristiques avancée suivantes:
 \begin{enumerate}
 
   \item typage d'occurrence
@@ -131,63 +131,64 @@ Le but the cette thèse est d'arriver à définir et étudier un langage de prog
 
   \item typage graduel  et inférence de types
 
-  \item polymorphisme paramètrique
+  \item polymorphisme paramétrique
 
-  \item types recursifs
+  \item types récursifs
     
   \item effets et ordre supérieur
 
   \item raffinement de types  
 
 \end{enumerate}
-Nous allons montrer par des exemples l'intérêt de chaque characteristique:
+Nous allons montrer par des exemples l'intérêt de chaque caractéristique:
 
 \paragraph{Typage d'occurrence:}
 Le typage de occurrence, ou \emph{occurrence typing} est un technique
 qui analyse les test effectués par un programme pour pouvoir raffiner
-l'analyses de types dans le code à executer en cas de reussite ou
-d'échec du test. Un example d'application du typage d'occurrence est donné par le
+l'analyses de types dans le code à exécuter en cas de réussite ou
+d'échec du test. Un exemple d'application du typage d'occurrence est donné par le
 code suivant JavaScript
 \begin{alltt}
   function foo(x) {
       (typeof(x) === "number")? x++ : x.trim()
   }
 \end{alltt}
-Dans ce code on teste si l'argument de la fonction \code{x} et de type
+Dans ce code on teste si l'argument de la fonction \code{x} est de type
 \code{number}; si oui on renvoie le successeur de l'argument et si non
 on lui envoie le message \code{trim()}. Puisque \code{trim} est une
 méthode définie seulement pour les valeurs de type \code{string}
-(c'est une méthode du standard ECMAScript 5 qui elimines les espeace
-au debut et à la fin d'une chaine de caractères) on peut facilement
-déduire que l'argument de \code{foo} doit être ou un \code{number} ou
-un \code{string}. C'est à dire il doit avoir le type
-\code{number|string}. Cette information n'est pas suffisante dans le
-systèmes de types standard pour typer la fonction \code{foo} car
-\code{trim()} n'est pas défini pour \code{numbers} et \code{++} n'est
+(c'est une méthode du standard ECMAScript 5 qui élimines les espaces
+au début et à la fin d'une chaine de caractères) on peut facilement
+déduire que l'argument de \code{foo} doit être de type \code{number} ou
+ \code{string}. C'est à dire il doit avoir le type
+\code{number|string}. Dans les
+systèmes de types standard  cette information n'est pas suffisante pour
+pouvoir typer la fonction \code{foo} car
+\code{trim()} n'est pas défini pour \code{number} et \code{++} n'est
 pas définie pour \code{string}. Ceci parce que les systèmes de types
 standard ne prennent pas en compte le test de type effectué sur
 \code{x}. Le typage d'occurrence est la technique qui utilise cette
-information pour spécializer le type des occurrences de \code{x} dans
-les differentes branches du test: puisque le programme à testé que
+information pour spécialiser le type des occurrences de \code{x} dans
+de manière différente dans chaque branche du test: puisque le programme a testé que
 \code{x} est de type \code{number}, alors nous pouvons supposer que
-\code{x} est de type \code{number} dans la branch ``then'' du test, et
+\code{x} est de type \code{number} dans la branche ``then'' du test, et
 qu'il \emph{n'est pas} de type \code{number} dans la branche ``else''
 et du fait qu'il doit être ou \code{number} ou \code{string} déduire
 qu'il est de type \code{string} dans cette branche.
 
 
-Initialement défini pour Scheme pour pouvoir typer des programme
-Schemes non typés\cite{THF08,THF10}, il est de plus en plus développé
+Initialement défini pour le langage Scheme pour pouvoir typer des programme
+Scheme non typés\cite{THF08,THF10}, il est de plus en plus développé
 et utilisé dans l'industrie (Hack, Typescript, Flow) car il est
 indispensable pour pourvoir analyser des patterns de programmation
-typiques de la programmation en langages dynamiques.
+typiquement utilisé en programmation par des langages dynamiques.
 
 \paragraph{Types ensemblistes:}
-comme nous vénons de voir les types ensemblistes sont intimement liés
+comme nous venons de voir les types ensemblistes sont intimement liés
 à l'occurrence typing. Le type que on déduira pour la fonction
 \code{foo} sera \code{number|string $\to$ number|string}: une fonction
 qui mappe un type union dans un type union. Nous avons aussi déjà vu
-l'utilisation du type negation: quand nous avons dit que dans la
+l'utilisation du type négation: quand nous avons dit que dans la
 branche ``else'' l'occurrence de \code{x} n'est pas de type
 \code{number} cela signifie qu'elle est de type
 \code{$\neg$number}. Et puisque \code{x} doit aussi avoir le type
@@ -198,8 +199,8 @@ branche ``else'' l'occurrence de \code{x} n'est pas de type
 pourrait aussi utiliser un type intersection pour donner un type bien
 plus précis à \code{foo} tel
 \code{(number$\to$number)\&(string$\to$string)} qui capture le fait
-que \code{foo} appliqué à un entier renvoie un entrier et qu'appliquée
-à une chaine de caaractères renvoie une chaine de caractères.
+que \code{foo} appliquée à un entier renvoie un entier et qu'appliquée
+à une chaine de caractères renvoie une chaine de caractères.
 
 \paragraph{Typage graduel et inférence de types:}
 nous avons déjà vous que une certaine dose de inférence de types est
@@ -207,64 +208,106 @@ nécessaire: la fonction \code{foo} n'a pas d'annotation de type mais
 on veut déduire qu'elle est de type \code{number|string $\to$
   number|string} ou, ce qui est encore plus difficile à déduire, de
 type \code{(number$\to$number)\&(string$\to$string)}. Si la première
-deduction est déjà possible, la deuxième le sera surement grâce aux
+déduction est déjà possible dans les systèmes actuels, la deuxième le sera surement grâce aux
 techniques développés dans cette thèse. Toutefois une tel déduction
 n'est pas toujours possible, c'est pourquoi il faudra avoir la
-possibilité de mélanger de zone du programme typés statiquement avec
-d'autres zones types. C'est exactement le but du \emph{typage graduel}
-qui permet d'annoter certaine partie du programme par un type inconnu
-\dyn, qui signale au compilateur que du typage statique peut être
-relaché au cout d'un controôle dynamique des types. Par example la
-fonction \code{foo} pourrait définie comme:
+possibilité de mélanger des zones du programme typées statiquement avec
+d'autres zones typées dynamiquement C'est exactement le but du \emph{typage graduel}
+qui permet d'annoter certaines parties du programme par un type inconnu
+\dyn, qui signale au compilateur que le typage statique peut être
+relâche au cout d'un contrôle dynamique des types. Par exemple la
+fonction \code{foo} pourrait être définie comme:
 \begin{alltt}
   function foo(x:\dyn) {
       (typeof(x) === "number")? x++ : x.trim()
   }
 \end{alltt}
-elle serait donc typé par \code{\dyn$\to$(number|string)} mais le
-compilateur introduirait de test dynamique qui controleraient à
-l'execution que lors de l'execution de \code{x++} la variable est liée
+elle serait donc typée par \code{\dyn$\to$(number|string)} et le
+compilateur introduirait des tests dynamiques qui contrôleraient à
+l’exécution que lors de l’exécution de \code{x++} la variable est liée
 à un entier et que lors de l'exécution de \code{x.trim()} la variable
 est liée à une chaine de caractères.
 
 
-\paragraph{Polymorphisme parametrique:} le polymorphisme parametrique
-est desormais nécessaire dans un langage de programmation moderne pour
-typer ...
+\paragraph{Polymorphisme paramétrique:} le polymorphisme paramétrique
+est désormais un outil incontournable dans un langage de programmation moderne pour
+pouvoir capturer ...
 
 Un simple exemple de cette nécessitée peut être obtenu en
-modifiant legèrement le code de \code{foo} de façon que la brabch
-``else'' renvoie l'argument inchangée:
+modifiant légèrement le code de \code{foo} de façon que la branche
+``else'' renvoie l'argument inchangé:
 \begin{alltt}
   function foo(x) {
       (typeof(x) === "number")? x++ : x
   }
 \end{alltt}
-dans ce cas il est clair que \code{foo} renvoie toujours un resultat
+dans ce cas il est clair que \code{foo} renvoie toujours un résultat
 qui a le même type que l'argument. Ceci est exprimé par le type
 polymorphe $\forall\alpha.\alpha\to\alpha$. Mais il se peut que le
-polymorphisme parametrique doive se combiner avec les caracteristique
-précédente. Si par exemple la branche ``then'' teste si l'argument est
+polymorphisme paramétrique doive se combiner avec les caractéristiques
+précédentes. Si par exemple la branche ``then'' teste si l'argument est
 égal à 42
 \begin{alltt}
   function foo(x) {
       (typeof(x) === "number")? (x==42) : x
   }
 \end{alltt}
-alor le type que on veut déduire pour cette fonction est:
+alors le type que on veut déduire pour cette fonction est:
 $\forall\alpha.$\code{(number$\to$boolean)\&(($\alpha\setminus$number)$\to$($\alpha\setminus$number))}. Autrement
 dit, si \code{foo} est appliqué à un entier alors il renvoie un
 booléen, sinon s'il est applique à un type qui n'est pas \code{number}
-il renvoie un resultat du même type.
+il renvoie un résultat du même type.
 
 
+\paragraph{Types récursifs, effets et ordre supérieur:}
+comme le polymorphisme paramétrique, ainsi les types récursifs les
+effets et les fonctions d'ordre supérieure sont des caractéristiques
+importantes dans un langage de programmation moderne. Ici il ne s'agit
+pas de trouver des nouvelles fonctionnalités mais d'étudier comment
+intégrer ces caractéristiques avec celle énoncées ci dessus.
+[developper?]
 
-CHALLENGES
+\paragraph{Raffinement de types:}
+nous avons déjà montré deux ex amples de raffinent de types: le typage
+d'occurrence permet de raffiner le type des occurrence d'une
+expression de manière différente dans les branches d'un test; une
+meilleure inférence des types permettrait de raffiner le type
+\code{number|string $\to$ number|string} de \code{foo} dans le type
+\code{(number$\to$number)\&(string$\to$string)} qui est bien plus
+précis On voudrait ajouter la possibilité de raffiner les types du
+langages par le biais de proposition logique. Par exemple on voudrait
+définir le type de nombre impair comme il suit $\texttt{Odd} = \{
+x\in\texttt{Int}~|~x\mod 2 = 1\}$: \texttt{Odd} est un raffinement du
+type \texttt{Int}. Il existe déjà une littérature abondante sur ce
+sujet. La spécificité dans cette thèse serait de utiliser ces types en
+combinaison avec les types ensemblistes pour généraliser le typage
+d'occurrence: si nous avons un test sur une expression booléenne $e$
+et $x$ est une variable libre dans $e$ de type $t$ alors on pourrait
+raffiner son type par $\{x\in t~|~e\}$ dans la branche ``then'' et
+$\{x\in t~|~\neg e\}$ dans la branche ``else''.
 
-Tous ces sujets ont été étudiés separament ainsi que pour certains
-leur combinaison. Mais l'integration de toutes ses characteristiques
-ensemble pose de nouveaux défis qui demande non seulment des avances
-sur chaqun de ses sujets mais ...
+
+
+
+  
+\subsection{Objectifs}
+
+La plupart de ces sujets ont été étudiés séparément et pour certains
+on a étudié leur combinaison. Mais l’intégration de toutes ses
+caractéristiques ensemble dans un langage unique pose de nouveaux
+défis qui demandent non seulement des avances sur chaque de ses sujets
+mais sur leur combinaison. L'inférence de types intersection pour le
+fonctions nécessitera d'une analyse fine que sera fournie par le
+typage des occurrence et une analyse de contrôle de flot que on
+tachera d'intégrer avec cette dernière. Cette analyse pourra aussi
+être utilisée pour al gestion des effets. Pour ces derniers nous
+envisageons d'utiliser les travaux sur les effets algébriques en le
+combinant avec l'expressivité logiques des types
+ensemblistes L'inférence de type polymorphe sera basée sur la
+génération d'ensemble de contraintes dont la solution utilisera les
+types récursifs et les types ensemblistes. Le typage d'occurrence sera
+utilisé pour optimiser la compilation de systèmes graduels afin de
+réduire le nombre de contrôles dynamiques.
 
 
 
@@ -287,13 +330,13 @@ dynamiques » n'ayant pas pu être analysées.
 
 Cette analyse statique de langages dynamiques est particulièrement
 importante dans le contexte actuel de la science des données. En
-effet, les langages de choix des analystes de données sont usuelement
+effet, les langages de choix des analystes de données sont usuellement
 des langages dynamiques (en particulier Python pour la physique, R
 pour les statistiques et JavaScript pour la programmation
 Web). L'amélioration de tels langages dans ce contexte est l'un des
 objectifs de la chaire de recherche « Langages de programmation
 Orientés Données » de la fondation Paris-Saclay, portée par K. Nguyen.
-Cette chaire, financée par une donnation d'Oracle Labs. Il est prévu
+Cette chaire, financée par une donation d'Oracle Labs. Il est prévu
 que la chaire prennent entre autre en charge les missions du doctorant
 ou de la doctorante retenu pour cette thèse.
 
@@ -305,7 +348,7 @@ au sein d'un prototype d'un langage alliant typage d'occurrences,
 sous-typage sémantique polymorphisme et inférence de
 types. Les points d'attention dans ce premier pan de la recherche sont
 en particulier la définition formelle du langage, qui devra être
-suffisemment modulaire pour être étendue avec d'autres aspects, un
+suffisamment modulaire pour être étendue avec d'autres aspects, un
 cadre théorique permettant la définition d'heuristiques et leur
 expérimentation pour l'inférence de types et un implémentation
 raisonnablement efficace (en particulier de l'algorithme de génération