racket
functies

Syntaxis

• (definiëren (naam argumenten ...) body)

• (functieargumenten ...)

Eenvoudige functie-oproepen

U kunt een functie in Racket aanroepen door deze tussen haakjes te plaatsen met de argumenten erachter. Dit ziet eruit als (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"

Bewerkingen zoals + en * zijn ook functies en ze gebruiken dezelfde syntaxis als het aanroepen van f of g .

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

Zie Functie-aanroepen in de Racket Guide voor meer informatie en voorbeelden.

Trefwoord argumenten

Racketfuncties kunnen ook trefwoordargumenten hebben, die worden gespecificeerd met een trefwoord gevolgd door de argumentuitdrukking. Een trefwoord begint met de tekens #: #:keyword arg-expr dus een trefwoordargument ziet eruit als #:keyword arg-expr . Binnen een functieaanroep ziet dit eruit (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

Zie Trefwoordargumenten in de Racket Guide voor meer informatie en voorbeelden.

De `pas toe'-functie

Als je een lijst hebt en je wilt de elementen van die lijst gebruiken als argumenten voor een functie, dan is wat je wilt 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 heeft twee argumenten. Het eerste argument is de functie die moet worden toegepast en het tweede argument is de lijst met de argumenten.

Een apply zoals

(apply + (list 1 2 3 4))

Is gelijk aan

(+ 1 2 3 4)

Het grote voordeel van apply is dat het werkt op willekeurige berekende lijsten, inclusief bijgevoegde lijsten en lijsten die afkomstig zijn van functieargumenten.

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

Zie De apply functie in de Racket Guide voor meer informatie en voorbeelden.

Functiedefinities

Functies in Racket kunnen worden gemaakt met de lambda vorm. Het formulier bevat een lijst met argumenten en een hoofdtekst.

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

In het bovenstaande voorbeeld neemt de functie twee argumenten aan en retourneert het resultaat door ze te vermenigvuldigen.

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

Het is vervelend om de functie en het hoofdgedeelte telkens opnieuw te schrijven als we twee getallen willen vermenigvuldigen, dus laten we het een naam geven. Gebruik het define om het een naam te geven. Hiermee worden functies aan een naam gekoppeld.

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

Nu kunnen we naar onze functie verwijzen door multiply aan te roepen

> (multiply 5 2)
10

Aangezien het heel gebruikelijk is om procedures aan namen te binden, biedt Racket een steno om functies te definiëren met behulp van het definieerformulier.

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

Zie Functies: lambda in de Racket Guide voor meer informatie en voorbeelden.