racket
Funktionen höherer Ordnung

Karte

Map wendet eine Funktion auf jedes Element einer Liste an:

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

Falten

Fold Right wendet nacheinander eine Funktion mit zwei Argumenten auf jedes Element in einer Liste von links nach rechts an, beginnend mit einem Basiswert:

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 führt dieselbe Aktion in die entgegengesetzte Richtung aus:

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)

Filter

filter gibt eine Liste aller #f in der angegebenen Liste zurück, für die das angegebene Prädikat einen Nicht- #f Wert zurückgibt.

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

Komponieren

Lässt Sie mehrere Funktionen f₀ f₁ … fₙ . Sie gibt eine Funktion zurück, die nacheinander fₙ auf ihre Argumente fₙ₋₁ , dann fₙ₋₁ auf das Ergebnis von fₙ und so weiter. Funktion wird von rechts nach links angewendet, wie für die mathematische Funktionszusammensetzung: (f ∘ g ∘ h)(x) = f(g(h(x))) .

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

Die Arity jeder Funktion sollte die Anzahl der zurückgegebenen Werte der Funktion unmittelbar rechts davon enthalten. Die Funktion ganz rechts bestimmt die Gesamtheit der Komposition. Die Funktion compose1 schreibt vor, dass die Funktionen einen Wert zurückgeben und ein Argument erwarten. Compose1 beschränkt jedoch weder die Eingabearität der letzten Funktion noch die Ausgabearität der ersten Funktion.

[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

Gibt eine teilweise angewendete Funktion zurück.

> ((curry + 10) 20)
30

curryr kann verwendet werden, wenn die Argumente am Ende eingefügt werden müssen. Mit anderen Worten, (curryr list 1 2) erzeugt eine Funktion, die einige new-arguments ... erwartet new-arguments ... Beim Aufruf ruft diese neue Funktion ihrerseits auf (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