racket
Högre ordningsfunktioner

Karta

Map tillämpar en funktion för varje element i en lista:

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")

Vika ihop

Fold Right tillämpar successivt en tvåargumentfunktion på varje element i en lista från vänster till höger med början med ett basvärde:

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)

Vik vänster utför samma åtgärd i motsatt riktning:

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)

Filtrera

filter returnerar en lista över varje objekt i den givna listan för vilken det givna predikatet returnerar ett icke- #f värde.

;; 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) 

Komponera

Låter dig komponera flera funktioner f₀ f₁ … fₙ . Det returnerar en funktion som successivt kommer att tillämpa fₙ på dess argument, sedan fₙ₋₁ till resultatet av fₙ och så vidare. Funktion tillämpas från höger till vänster, som för matematisk funktionskomposition: (f ∘ g ∘ h)(x) = f(g(h(x))) .

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

Arityen för varje funktion bör omfatta antalet returnerade värden för funktionen omedelbart till höger. Funktionen längst till höger bestämmer hela kompositionens arity. Funktionen compose1 innebär att funktionerna returnerar ett värde och förväntar sig ett argument. Compose1 begränsar emellertid inte ingångsariteten för den sista funktionen, och inte heller den första funktionens utgångsaritet.

[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

Returnerar en delvis tillämpad funktion.

> ((curry + 10) 20)
30

curryr kan användas när argumenten måste infogas i slutet. Med andra ord, (curryr list 1 2) kommer att producera en funktion som förväntar sig några new-arguments ... När den anropas kommer den nya funktionen i sin tur att ringa (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