racket
Funktionen

Syntax

• (Definiere (Namensargumente ...) Körper)

• (Funktionsargumente ...)

Einfache Funktionsaufrufe

Sie können eine Funktion in Racket aufrufen, indem Sie sie mit den Argumenten hinterher in Klammern einschließen. Das sieht so aus (function argument ...) .

> (define (f x) x)
> (f 1)
1
> (f "salmon")
"salmon"
> (define (g x y) (string-append x y))
> (g "large" "salmon")
"largesalmon"
> (g "large " "salmon")
"large salmon"

Operationen wie + und * sind ebenfalls Funktionen und verwenden dieselbe Syntax wie der Aufruf von f oder g .

> (+ 1 2)
3
> (* 3 4)
12
> (+ (* 3 3) (* 4 4))
25

Weitere Informationen und Beispiele finden Sie unter Funktionsaufrufe im Racket Guide.

Keyword-Argumente

Racketfunktionen können auch Schlüsselwortargumente enthalten , die mit einem Schlüsselwort gefolgt vom Argumentausdruck angegeben werden. Ein Schlüsselwort beginnt mit den Zeichen #: #:keyword arg-expr sieht ein Schlüsselwortargument wie #:keyword arg-expr . Innerhalb eines Funktionsaufrufs sieht dies folgendermaßen aus (function #:keyword arg-expr) .

> (define (hello #:name n)
    (string-append "Hello " n))
> (hello #:name "John")
"Hello John"
> (hello #:name "Sarah")
"Hello Sarah"
> (define (kinetic-energy #:mass m #:velocity v)
    (* 1/2 m (sqr v)))
> (kinetic-energy #:mass 2 #:velocity 1)
1
> (kinetic-energy #:mass 6 #:velocity 2)
12

Weitere Informationen und Beispiele finden Sie unter Keyword-Argumente im Racket-Handbuch.

Die `Apply'-Funktion

Wenn Sie eine Liste haben und die Elemente dieser Liste als Argumente für eine Funktion verwenden möchten, gilt apply :

> (apply string-append (list "hello" " " "and hi" " " "are both words"))
"hello and hi are both words"
> (apply + (list 1 2 3 4))
10
> (apply append (list (list "a" "b" "c") (list 1 2 3) (list "do" "re" "mi")))
(list "a" "b" "c" 1 2 3 "do" "re" "me")

apply erfordert zwei Argumente. Das erste Argument ist die anzuwendende Funktion und das zweite Argument ist die Liste mit den Argumenten.

Eine apply Aufruf wie

(apply + (list 1 2 3 4))

Ist äquivalent zu

(+ 1 2 3 4)

Der Hauptvorteil von apply ist, dass es auf beliebig berechneten Listen funktioniert, einschließlich angehängter Listen und Listen, die aus Funktionsargumenten stammen.

> (apply + (append (list 1 2 3 4) (list 2 3 4)))
19
> (define (sum lst)
    (apply + lst))
> (sum (list 1 2 3 4))
10
> (sum (append (list 1 2 3 4) (list 2 3 4)))
19

Weitere Informationen und Beispiele finden Sie unter Die apply Funktion im Racket Guide.

Funktionsdefinitionen

Funktionen in Racket können mit dem lambda Formular erstellt werden. Das Formular enthält eine Liste von Argumenten und einen Hauptteil.

(lambda (x y) (* x y))

Im obigen Beispiel nimmt die Funktion zwei Argumente auf und gibt das Ergebnis ihrer Multiplikation zurück.

> ((lambda (x y) (* x y)) 4 4)
16
> ((lambda (x y) (* x y)) 3 2)
6

Es ist langwierig, die Funktion und ihren Körper jedes Mal neu zu schreiben, wenn wir zwei Zahlen multiplizieren möchten. Geben wir ihr also einen Namen. Um ihm einen Namen zu geben, verwenden Sie das define . Dadurch werden Funktionen an einen Namen gebunden.

(define multiply (lambda (x y) (* x y)))

Jetzt können wir uns auf unsere Funktion beziehen, indem wir multiply aufrufen

> (multiply 5 2)
10

Da es sehr üblich ist, Prozeduren an Namen zu binden, bietet Racket eine Abkürzung, um Funktionen mithilfe des Definitionsformulars zu definieren.

(define (multiply x y) (* x y))

Weitere Informationen und Beispiele finden Sie unter Funktionen: Lambda im Racket Guide.