racket
Funciones

Sintaxis

• (definir (nombrar argumentos ...) cuerpo)

• (argumentos de función ...)

Llamadas de función simple

Puede llamar a una función en Racket envolviéndola entre paréntesis con los argumentos detrás de ella. Esto parece (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"

Las operaciones como + y * son funciones, y usan la misma sintaxis que la llamada f o g .

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

Para obtener más información y ejemplos, consulte Llamadas de funciones en la Guía de la raqueta.

Argumentos de palabras clave

Las funciones de raqueta también pueden tener argumentos de palabras clave , que se especifican con una palabra clave seguida de la expresión de argumento. Una palabra clave comienza con los caracteres #: por lo que un argumento de palabra clave se ve como #:keyword arg-expr . Dentro de una llamada de función, este aspecto se ve (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

Para obtener más información y ejemplos, consulte Argumentos de palabras clave en la Guía de Racket.

La función `apply`

Si tiene una lista y desea utilizar los elementos de esa lista como argumentos para una función, se apply lo que desea:

> (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 toma dos argumentos. El primer argumento es la función a aplicar, y el segundo argumento es la lista que contiene los argumentos.

Una llamada de apply como

(apply + (list 1 2 3 4))

Es equivalente a

(+ 1 2 3 4)

La principal ventaja de apply es que funciona en listas calculadas arbitrarias, incluidas listas agregadas y listas que provienen de argumentos de función.

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

Para obtener más información y ejemplos, consulte La función de apply en la Guía de raquetas.

Definiciones de funciones

Las funciones en Racket se pueden crear con el formulario lambda . La forma toma una lista de argumentos y un cuerpo.

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

En el ejemplo anterior, la función toma dos argumentos y devuelve el resultado de multiplicarlos.

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

Es tedioso volver a escribir la función y su cuerpo cada vez que queremos multiplicar dos números, así que démosle un nombre. Para darle un nombre, usa la forma de define . Esto enlazará funciones a un nombre.

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

Ahora podemos referirnos a nuestra función llamando a multiply

> (multiply 5 2)
10

Dado que es muy común vincular procedimientos a nombres, Racket proporciona una forma abreviada para definir funciones utilizando la forma de definir.

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

Para obtener más información y ejemplos, consulte Funciones: lambda en la Guía de Racket.