Strukturierung: Die Listenfunktion map und anonyme Funktionen

Listen verändern mit map

Möchten wir alle Elemente einer Liste verarbeiten, benötigen wir eine Möglichkeit, Funktionen auf jedes einzelne Element einer Liste anzuwenden. Hierfür wird die Funktion map genutzt. Zu beachten ist, dass die Rückgabe des map-Ausdrucks eine neue Liste darstellt. (Stichwort: Unveränderlichkeit). Die übergebene Liste bleibt unverändert.

Der Aufbau eines korrekten map-Ausdrucks in Racket besteht aus:

1. Dem Operator map
2. Einer Funktion als ersten Operanden
3. Einer Liste als zweiten Operanden.

(map natural? (list 42 17 24 4.1))

(map string-length (list "Informatik" "Racket" "Funktion"))

Bei Ausführung des Ausdrucks wird die übergebene Funktion auf alle Elemente der übergebenen Liste angewandt. Damit dies gelingt, müssen die Signaturen der Funktionen beachtet werden! Die Anzahl und der Datentyp eines Elements in der Liste müssen den erwarteten Übergabedaten der anzuwendenden Funktion entsprechen.

Aufgabe 1: Zulässige Funktionen

(a) Bestimme und begründe, welche der Ausdrücke korrekt sind und welche nicht:

;I
(map string-length (list 1 4 10 5 6))

;II
(map string? (list "Hallo" "Welt" "!"))

;III
(map string? (list 4.5 7 8 #t 18))

;IV
(map ceiling (list (list 1 2 3) (list 3 4 5) (list 6 7 8)))

;V
(map < 0 (list 17 -15 15 0 -4))

Anonyme Funktionen

Möchten wir Funktionen auf die Elemente der Liste anwenden, die nicht nativ in Racket vorhanden sind, können wir diese wie gewohnt selbst definieren ...

(define verdopple
  (lambda (x)
    (* x 2)
))  

... und anschließend im map-Ausdruck anwenden:

(map verdopple (list 0 1 2 3))

Da man im Zweifelsfall nicht für jede Verarbeitung eine neue Funktion definieren möchte, gibt es die Möglichkeit, die Logik der Funktion innerhalb des map-Ausdrucks zu verfassen.

Anstelle eines Funktionsnamens wird in den map-Ausdruck der gesamte lambda-Ausdruck einer theoretischen Funktionsdefinition geschrieben.

Der Ausdruck ...

(map (lambda (x) (* x 2)) (list 0 1 2 3))

... liefert somit dasselbe Ergebnis wie:

(define verdopple
  (lambda (x)
    (* x 2)
))

(map verdopple (list 0 1 2 3))

Einen lambda-Ausdruck, ohne eine Funktionsdefinition mittels define, nennen wir eine anonyme Funktion.

Eine anonyme Funktion ist im Code nicht wiederverwendbar, da sie mit keinem Funktionsnamen aufgerufen werden kann. Bei einmaliger Nutzung oder kurzer Funktionslogik ist eine Funktionsdefinition jedoch nicht zwingend notwendig und es kann den Code übersichtlicher gestalten, anonyme Funktionen zu nutzen. Ob du für deine Programme anonyme Funktionen nutzen willst oder nicht, ist sozusagen Geschmackssache und am Ende deine eigene Entscheidung.

Aufgabe 2: Definitionen und anonyme Funktionen

(a) Betrachte die folgenden zwei Definitionen...

(define minus-eins-v1
  (lambda (x)
    (- x 1)
))

(define minus-eins-v2
  ((lambda (x)
    (- x 1)) 20)
)

... welche Ausgaben in der REPL erwartest du nach der Ausführung der folgenden beiden Zeilen?

> minus-eins-v1
> minus-eins-v2

(b) Überprüfe deine Vermutung aus (a).

(c) Bei welchem der beiden lambda-Ausdrücke handelt es sich um eine anonyme Funktion?

Aufgabe 3: Nutzung von anonymen Funktionen

(a) Entwerfe einen Racket Ausdruck, der eine Liste zurückgibt, deren Elemente jeweils die doppelte Zeichenanzahl der Elemente folgender Liste enthalten: (list "Informatik" "Racket" "Funktion"). Nutze dazu eine anonyme Funktion.

(b) Für eine Prüfung wurde folgende anonymisierte Notenliste veröffentlicht:
(list 9 4 7 11 9 10 8 10 10 8 3 7 13 7 15 5 3 8 11 6 7)
Schreibe einen Ausdruck, der eine Liste zurückgibt, welche für jeden Notenwert bestimmt, ob dieser als bestanden (#t) oder nicht bestanden (#f) zu werten ist. Nutze dazu eine anonyme Funktion.