racket
funktioner

Syntax

• (definiera (namnge argument ...) organ)

• (funktionsargument ...)

Enkla funktionssamtal

Du kan ringa en funktion i Racket genom att lägga in den inom parentes med argumenten efter den. Detta ser ut (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"

Funktioner som + och * är också funktioner, och de använder samma syntax som att ringa f eller g .

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

Mer information och exempel finns i Funktionssamtal i racketguiden.

Sökordsargument

Racketfunktioner kan också ha nyckelordargument , som specificeras med ett nyckelord följt av argumentuttrycket. Ett nyckelord börjar med tecknen #: #:keyword arg-expr så ett nyckelordargument ser ut som #:keyword arg-expr . Inom ett funktionssamtal ser detta ut (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

Mer information och exempel finns i Sökordsargument i racketguiden.

Funktionen "applicera"

Om du har en lista, och du vill använda delar av denna lista som argument till en funktion, vad du vill är 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 tar två argument. Det första argumentet är funktionen som ska tillämpas, och det andra argumentet är listan som innehåller argumenten.

Ett apply som

(apply + (list 1 2 3 4))

Är ekvivalent med

(+ 1 2 3 4)

Den största fördelen med apply är att det fungerar på godtyckliga datorlistor, inklusive bifogade listor och listor som kommer från funktionsargument.

> (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

För mer information och exempel, se apply funktionen i racketguiden.

Funktionsdefinitioner

Funktioner i racket kan skapas med lambda formen. Formen tar en lista med argument och ett organ.

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

I exemplet ovan tar funktionen två argument och returnerar resultatet av att multiplicera dem.

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

Det är tråkigt att skriva om funktionen och dess kropp varje gång vi vill multiplicera två siffror, så låt oss ge den ett namn. define formuläret för att ge det ett namn. Detta kommer att binda funktioner till ett namn.

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

Nu kan vi hänvisa till vår funktion genom att ringa multiply

> (multiply 5 2)
10

Eftersom det är mycket vanligt att binda procedurer till namn, ger Racket en korthet för att definiera funktioner med hjälp av definiera formen.

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

För mer information och exempel, se Funktioner: lambda i racketguiden.