racket
Fonctions d'ordre supérieur

Carte

Map applique une fonction à chaque élément d'une liste:

map: (a -> b) (listof a) -> (listof b)

> (map (lambda (x) (* x 2)) (list 1 2 3 4 5)
(list 2 4 6 8 10)

> (map sqrt (list 1 4 9))
(list 1 2 3)

> (map (lambda (x) (if (even? x) "even" "odd")) (list 1 2 3))
(list "odd" "even" "odd")

Plier

Fold Right applique successivement une fonction à deux arguments à chaque élément d'une liste de gauche à droite en commençant par une valeur de base:

foldr: (a b -> b) b (listof a) -> b

> (foldr + 0 (list 1 2 3 4))
10

> (foldr string-append "" (list "h" "e" "l" "l" "o"))
"hello"

> (foldr cons empty (list 1 2 3 4))
(list 1 2 3 4)

Fold Left effectue la même action dans la direction opposée:

foldl: (a b -> b) b (listof a) -> b

> (foldl + 0 (list 1 2 3 4)
10

> (foldl string-append "" (list "h" "e" "l" "l" "o"))
"olleh"

> (foldl cons empty (list 1 2 3 4))
(list 4 3 2 1)

Filtre

filter renvoie une liste de chaque élément de la liste donnée pour laquelle le prédicat donné renvoie une valeur non #f .

;; Get only even numbers in a list
> (filter even? '(1 2 3 4))
'(2 4)

;; Get all square numbers from 1 to 100
> (filter (lambda (n) (integer? (sqrt n))) (range 1 100))
'(1 4 9 16 25 36 49 64 81) 

Composer

Vous permet de composer plusieurs fonctions f₀ f₁ … fₙ . Il renvoie une fonction qui appliquera successivement fₙ à ses arguments, puis fₙ₋₁ au résultat de fₙ et ainsi de suite. Les fonctions sont appliquées de droite à gauche, comme pour la composition mathématique des fonctions: (f ∘ g ∘ h)(x) = f(g(h(x))) .

> ((compose sqrt +) 16 9)
5
> ((compose - sqrt) 16)
-4

L'arité de chaque fonction devrait inclure le nombre de valeurs renvoyées de la fonction immédiatement à sa droite. La fonction la plus à droite détermine l'arité de la composition entière. La fonction compose1 impose que les fonctions renvoient 1 valeur et attendent 1 argument. Cependant, composer1 ne restreint pas l'arité d'entrée de la dernière fonction, ni celle de la première fonction.

[n input]--> first-function -->[1 output]--> ... last function -->[m output].

((compose + values) 1 2 3 4)
10
> ((compose1 + values) 1 2 3 4)
XX result arity mismatch;
 expected number of values not received
  expected: 1
  received: 4
  values...:

Curry

Renvoie une fonction partiellement appliquée.

> ((curry + 10) 20)
30

curryr peut être utilisé lorsque les arguments doivent être insérés à la fin. En d'autres termes, (curryr list 1 2) produira une fonction qui attend de new-arguments ... Lorsqu'elle est appelée, cette nouvelle fonction appelle à son tour (list new-arguments ... 1 2) .

> (((curryr list) 1 2) 3 4)
'(3 4 1 2)
> ((curryr list 1 2) 3 4)
'(3 4 1 2) 
> ((curryr - 30) 40)
10
> (((curryr -) 30 40))
10