racket
Les fonctions

Syntaxe

• (définir (nom des arguments ...) corps)

• (arguments de fonction ...)

Appels de fonction simples

Vous pouvez appeler une fonction dans Racket en la plaçant entre parenthèses avec les arguments qui suivent. Cela ressemble à (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"

Les opérations comme + et * sont également des fonctions, et elles utilisent la même syntaxe que d'appeler f ou g .

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

Pour plus d'informations et d'exemples, voir Appels de fonction dans le Guide de la raquette.

Arguments de mots clés

Les fonctions de raquette peuvent également avoir des arguments de mot - clé , qui sont spécifiés avec un mot-clé suivi de l'expression d'argument. Un mot-clé commence par les caractères #: :, un argument mot-clé ressemble à #:keyword arg-expr . Dans un appel de fonction, cela ressemble à (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

Pour plus d'informations et d'exemples, voir Arguments relatifs aux mots clés dans le Guide de la raquette.

La fonction `apply`

Si vous avez une liste et que vous souhaitez utiliser les éléments de cette liste comme arguments pour une fonction, vous devez 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 prend deux arguments. Le premier argument est la fonction à appliquer et le second argument est la liste contenant les arguments.

Un apply appel comme

(apply + (list 1 2 3 4))

Est équivalent à

(+ 1 2 3 4)

L'avantage majeur de apply est qu'il fonctionne sur des listes calculées arbitrairement, y compris les listes ajoutées et les listes provenant d'arguments de fonction.

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

Pour plus d' informations et des exemples, voir la apply fonction dans le Guide Racket.

Définitions de fonction

Les fonctions dans Racket peuvent être créées avec la forme lambda . Le formulaire prend une liste d'arguments et un corps.

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

Dans l'exemple ci-dessus, la fonction prend deux arguments et renvoie le résultat de leur multiplication.

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

Il est fastidieux de ré-écrire la fonction et son corps chaque fois que l'on veut multiplier deux nombres, alors donnons-lui un nom. Pour lui donner un nom, utilisez le formulaire de define . Cela liera les fonctions à un nom.

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

Maintenant, nous pouvons nous référer à notre fonction en appelant multiply

> (multiply 5 2)
10

Comme il est très courant de lier des procédures à des noms, Racket fournit un raccourci pour définir des fonctions à l'aide du formulaire de définition.

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

Pour plus d'informations et d'exemples, voir Fonctions: lambda dans le Guide de la raquette.