Julia Language
Fonctions d'ordre supérieur

Syntaxe

• foreach (f, xs)
• carte (f, xs)
• filtre (f, xs)
• réduire (f, v0, xs)
• foldl (f, v0, xs)
• foldr (f, v0, xs)

Remarques

Fonctionne comme des arguments

Les fonctions sont des objets dans Julia. Comme tous les autres objets, ils peuvent être transmis comme arguments à d'autres fonctions. Les fonctions qui acceptent des fonctions sont appelées fonctions d' ordre supérieur.

Par exemple, nous pouvons implémenter un équivalent de la fonction foreach de la bibliothèque standard en prenant une fonction f comme premier paramètre.

function myforeach(f, xs)
    for x in xs
        f(x)
    end
end

Nous pouvons tester que cette fonction fonctionne effectivement comme prévu:

julia> myforeach(println, ["a", "b", "c"])
a
b
c

En prenant une fonction comme premier paramètre, au lieu d'un paramètre ultérieur, nous pouvons utiliser la syntaxe de bloc de commande de Julia. La syntaxe do block est simplement un moyen pratique de passer une fonction anonyme en tant que premier argument à une fonction.

julia> myforeach([1, 2, 3]) do x
           println(x^x)
       end
1
4
27

Notre implémentation de myforeach ci-dessus est à peu près équivalente à la fonction intégrée foreach . De nombreuses autres fonctions intégrées d'ordre supérieur existent également.

Les fonctions d'ordre supérieur sont très puissantes. Parfois, lorsque vous travaillez avec des fonctions de niveau supérieur, les opérations exactes sont sans importance et les programmes peuvent devenir très abstraits. Les combinateurs sont des exemples de systèmes de fonctions hautement abstraites d'ordre supérieur.

Mapper, filtrer et réduire

Deux des fonctions les plus fondamentales de la bibliothèque standard sont map et filter . Ces fonctions sont génériques et peuvent fonctionner sur n'importe quel itérable . En particulier, ils conviennent parfaitement aux calculs sur les tableaux .

Supposons que nous ayons un ensemble de données sur les écoles. Chaque école enseigne une matière particulière, a un nombre de classes et un nombre moyen d'élèves par classe. Nous pouvons modéliser une école avec le type immuable suivant:

immutable School
    subject::Symbol
    nclasses::Int
    nstudents::Int  # average no. of students per class
end

Notre ensemble de données sur les écoles sera un Vector{School} :

dataset = [School(:math, 3, 30), School(:math, 5, 20), School(:science, 10, 5)]

Supposons que nous souhaitons trouver le nombre total d’élèves inscrits dans un programme de mathématiques. Pour ce faire, nous avons besoin de plusieurs étapes:

• nous devons restreindre le jeu de données aux seules écoles qui enseignent les mathématiques ( filter )
• nous devons calculer le nombre d'étudiants à chaque école ( map )
• et nous devons réduire cette liste de nombres d’étudiants à une seule valeur, la somme ( reduce )

Une solution naïve (pas la plus performante) consisterait simplement à utiliser directement ces trois fonctions supérieures.

function nmath(data)
    maths = filter(x -> x.subject === :math, data)
    students = map(x -> x.nclasses * x.nstudents, maths)
    reduce(+, 0, students)
end

et nous vérifions qu'il y a 190 étudiants en mathématiques dans notre ensemble de données:

julia> nmath(dataset)
190

Des fonctions existent pour combiner ces fonctions et améliorer ainsi les performances. Par exemple, nous aurions pu utiliser la fonction mapreduce pour effectuer le mappage et la réduction en une seule étape, ce qui permettrait d'économiser du temps et de la mémoire.

La reduce n'a de sens que pour les opérations associatives comme + , mais il est parfois utile d'effectuer une réduction avec une opération non associative. Les fonctions d'ordre supérieur foldl et foldr sont fournies pour forcer un ordre de réduction particulier.