Les fonctions en détail

Dans la derniére partie de ce cours, nous allons aborder les bases de la programmation fonctionnelle avec R. La programmation fonctionnelle est une façon de programmer en utilisant uniquement des fonctions, en particulier pour remplacer les boucles. Il faut un peu de temps pour s'y habituer, mais c'est une façon d'écrire du code très puissante, très rapide, et qui permet d'éviter beaucoup d'erreurs. Beaucoup de programmeurs ne savent pas utiliser la programmation fonctionnelle, alors que c'est un outil qui change la vie ! C'est pourquoi il me semble important de vous en apprendre les bases dans la dernière partie de cet ouvrage. Vous pouvez passer votre vie sans utiliser la programmation fonctionnelle, mais quand vous en comprenderai l'utilité, vous ne voudrez probablement plus vous en passer.

Retour sur les fonctions

Pour commencer, nous allons en apprendre un peu plus les fonctions en R. Nous allons voir dans ce chapitre tous ce que vous devez savoir sur les fonctions.

Les composants d'une fonction

Une fonction en R se décompose en trois éléments :

le corps de la fonction (body ), la liste des arguments de la fonction (formals), et l'environnement auquel la fonction appartient. On peut afficher chacun de ses éléments à l'aide d'une fonction associée :

ma_fonction = function(x) {
    x + 1
}
body(ma_fonction)
formals(ma_fonction)
environment(ma_fonction)

Voici ce que nous affiche la console :

Si une fonction ne prend pas d'arguments, il est possible qu'elle n'ait pas de formals, qui affichera alors NULL . Mais une fonction à toujours un environnement et un corps. Une fonction "vide" à toujours un corps (qui est alors simplement {} .

Lors du chapitre sur les fonctions, nous avions vu que écrire simplement le nom de la fonction (sans l'appeler avec les () ) affiche la fonction elle-même :

ma_fonction

La console nous affiche ainsi les arguments de la fonction (formals), le corps de la fonction (body), mais où est l'environnement ? L'environnement n'est pas affiché, car il s'agit ici de l'environnement global. Mais si on affiche une fonction qui ne vit pas dans l'environnement global, l'environnement sera bien affiché ! Par exemple, affichons la fonction ggplot du package ggplote2 :

library("ggplot2") #on charge le package
ggplot

On obtient bien cette fois les trois composants de la fonction. La dernière ligne de la fonction précise l'environnement de la fonction, ici le package ggplot2.

Les fonctions primitive, ou builtin

Vous vous souvenez quand nous avons vu quelques fonctions utiles que nous avons fait la différence entre les fonctions de typebuiltin et les fonctions primitive ? Nous avions dit que la différence était que les fonctions builtin sont directement au coeur de R, et que seuls les développeurs du langage peuvent les modifier ou ajouter de nouvelles builtins.

La raison est simple : les fonctions builtin n'ont... pas de corps, ni de formals, ni d'environnement, ! En effet, le code qu'elles contiennent est directement écrit dans le langage C++. Elles n'appartiennent donc pas vraimant à R en un sens. Regardons ce qui se passe si on essaye de les afficher :

typeof(sum) #fonction de type "builtin"
body(sum) #le body n'existe pas !
formals(sum) #les arugments non plus !    
environment(sum) #Pas plus que l'environnement

Pourtant ces fonctions ont bien des arguments non ? Si on tente d'afficher une builtin par son nom, voici ce qu'on obtient :

R nous affiche alors les arguments de la fonction, par exemple l'argument na.rm qui permet d'enlever les données manquantes (NA ) de la somme.