racket
funzioni

Sintassi

• (definire (nome argomenti ...) corpo)

• (argomenti della funzione ...)

Chiamate di funzioni semplici

Puoi chiamare una funzione in Racket avvolgendola tra parentesi con gli argomenti dopo di essa. Sembra (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"

Anche le operazioni come + e * sono funzioni, e usano la stessa sintassi del chiamare f o g .

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

Per ulteriori informazioni ed esempi, vedere Chiamate di funzione nella Guida alla racchetta.

Argomenti della parola chiave

Le funzioni della racchetta possono anche avere argomenti di parole chiave , che sono specificati con una parola chiave seguita dall'espressione argomento. Una parola chiave inizia con i caratteri #: quindi un argomento di parole chiave assomiglia a #:keyword arg-expr . All'interno di una chiamata di funzione questo appare (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

Per ulteriori informazioni ed esempi, consultare Argomenti della parola chiave nella Guida della racchetta.

La funzione `apply`

Se si dispone di un elenco e si desidera utilizzare gli elementi di tale elenco come argomenti per una funzione, si apply ciò che si desidera:

> (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 prende due argomenti. Il primo argomento è la funzione da applicare e il secondo argomento è la lista che contiene gli argomenti.

apply chiamata come

(apply + (list 1 2 3 4))

È equivalente a

(+ 1 2 3 4)

Il vantaggio principale di apply è che funziona su liste calcolate arbitrarie, compresi gli elenchi e gli elenchi aggiunti che provengono da argomenti di funzione.

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

Per ulteriori informazioni ed esempi, consultare la funzione apply nella Guida alla racchetta.

Definizioni di funzione

Le funzioni in Racket possono essere create con il modulo lambda . Il modulo accetta un elenco di argomenti e un corpo.

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

Nell'esempio sopra, la funzione accetta due argomenti e restituisce il risultato della loro moltiplicazione.

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

È noioso riscrivere la funzione e il suo corpo ogni volta che vogliamo moltiplicare due numeri, quindi diamo un nome. Per dargli un nome, usa il modulo di define . Ciò collegherà le funzioni a un nome.

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

Ora possiamo fare riferimento alla nostra funzione chiamando multiply

> (multiply 5 2)
10

Poiché è molto comune associare le procedure ai nomi, Racket fornisce una scorciatoia per definire le funzioni utilizzando il modulo di definizione.

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

Per ulteriori informazioni ed esempi, consultare Funzioni: lambda nella Guida alla racchetta.