Julia encourage les développeurs à mettre autant de code que possible dans des fonctions que l'on peut compiler à la volée (JIT), et créer beaucoup de petites fonctions est performant par conception.
Il en résulte souvent beaucoup de petites fonctions simples, que l'on doit combiner pour mener à bien des tâches non triviales.
Une approche évidente consiste à imbriquer les appels de fonctions.
L'exemple suivant est très artificiel, mais il illustre bien le problème.
julia> first.(titlecase.(reverse.(["my", "test", "strings"])))
3-element Vector{Char}:
'Y': ASCII/Unicode U+0059 (category Lu: Letter, uppercase)
'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
'S': ASCII/Unicode U+0053 (category Lu: Letter, uppercase)
L'inconvénient de cette approche, c'est que la lisibilité chute rapidement à mesure que l'imbrication s'approfondit.
On a besoin d'une approche plus simple et plus souple.
Composition
C'est la technique préférée des mathématiciens, et Julia en reprend la syntaxe mathématique.
On peut composed un nombre arbitraire de fonctions avec des opérateurs ∘ (que l'on saisit avec \circ puis la tabulation).
Le résultat s'utilise comme une seule fonction.
julia> compfunc = first ∘ titlecase ∘ reverse
first ∘ titlecase ∘ reverse
julia> compfunc.(["my", "test", "strings"])
3-element Vector{Char}:
'Y': ASCII/Unicode U+0059 (category Lu: Letter, uppercase)
'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
'S': ASCII/Unicode U+0053 (category Lu: Letter, uppercase)
# alternative syntax, giving the same result
julia> (first ∘ titlecase ∘ reverse).(["my", "test", "strings"])
Quelques points à noter :
- Les fonctions de départ apparaissent dans le même ordre que lors de l'imbrication, et sont exécutées de droite à gauche.
- La diffusion n'est pas simple à utiliser quand on compose, mais elle peut s'appliquer au moment d'appeler la fonction composée.
Le pipeline
On peut aussi y voir l'approche des programmeurs, plutôt que celle des mathématiciens.
Les Pipelines sont utilisés depuis longtemps dans les scripts shell Unix, et sont devenus populaires plus récemment dans les langages de programmation grand public (on attribue parfois à F# le fait d'avoir été pionnier dans leur adoption).
Le principe de base : partir de quelques données, puis les faire passer dans une suite de fonctions pour obtenir le résultat.
L'opérateur pipe est |> (comme en F# et dans les versions récentes de R), même si Julia dispose aussi d'une version diffusée .|>.
julia> ["my", "test", "strings"] .|> reverse .|> titlecase .|> first
3-element Vector{Char}:
'Y': ASCII/Unicode U+0059 (category Lu: Letter, uppercase)
'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
'S': ASCII/Unicode U+0053 (category Lu: Letter, uppercase)
L'exécution se fait maintenant strictement de gauche à droite, la sortie de chaque fonction circulant dans le sens de la flèche pour devenir l'entrée de la fonction suivante.
Limites, contournements et autres options
Ce n'est pas un hasard si les fonctions utilisées pour illustrer la composition et le pipeline prennent toutes un seul argument.
Certains langages purement fonctionnels font passer le premier argument par une fonction, tout en permettant d'en fournir d'autres.
À l'inverse, Julia n'attend que des noms de fonctions (ou un équivalent) dans un pipeline, sans argument supplémentaire.
Cela tient à d'importantes raisons techniques (liées au fait que le currying ne fait pas partie de la conception standard du langage).
Les nombreuses personnes qui ne connaissent rien au currying doivent simplement accepter que cette limitation n'est pas un oubli, et qu'elle ne changera probablement pas dans les futures versions de Julia.
Les contournements
On a besoin de fonctions qui prennent un seul argument et qui font ce qu'il faut.
Heureusement, définir de nouvelles fonctions en Julia est facile.
Le plus simple est d'utiliser une anonymous function.
Par exemple, si on a une seule string en entrée et qu'on veut la découper sur les tirets bas :
julia> "my_test_strings" |> (s -> split(s, '_'))
3-element Vector{SubString{String}}:
"my"
"test"
"strings"
On peut ensuite faire passer ce vecteur dans d'autres fonctions, comme précédemment.
Mettre la fonction anonyme entre parenthèses est facultatif dans ce cas, mais de façon plus générale c'est un bon moyen de lever toute ambiguïté.
De la même façon, on peut créer une fonction nommée plus tôt dans le programme et la réutiliser au besoin.
Exercice d'apprentissage
