Thank you for your comment

Beau­tiful Racket / explainers

Functions

A func­tion is a set of expres­sions that’s only eval­u­ated when explic­itly invoked at run time. Option­ally, a func­tion can take argu­ments as input, and return values as output. Within a program, func­tions are used for three over­lap­ping purposes:

  1. To delay the eval­u­a­tion of a set of expres­sions.

  2. To allow repeated eval­u­a­tion of a set of expres­sions.

  3. To gener­alize a set of expres­sions by using input argu­ments.

Func­tions can be passed around Racket programs like any other value:

(define plus +)
(define another-plus +)
(equal? plus another-plus) ; true
(plus 30 12) ; 42
(another-plus 30 12) ; 42
1
2
3
4
5
(define plus +)
(define another-plus +)
(equal? plus another-plus) ; true
(plus 30 12) ; 42
(another-plus 30 12) ; 42
copy to clipboard

If a func­tion is created with define, it uses an iden­ti­fier for its name. A func­tion can also be created without a name (that is, as an anony­mous func­tion) using lambda, which can be spelled λ. A lambda expres­sion can appear anywhere that a func­tion name is allowed:

(define (plus x y) (+ x y))
(plus 30 12) ; 42
((lambda (x y) (+ x y)) 30 12) ; 42
1
2
3
(define (plus x y) (+ x y))
(plus 30 12) ; 42
((lambda (x y) (+ x y)) 30 12) ; 42
copy to clipboard

A lambda expres­sion can also be bound (assigned) to an iden­ti­fier. The two defi­n­i­tions below are equiv­a­lent (in fact, under the hood, Racket rewrites the first style of define in the lambda style):

(define (plus x y) (+ x y))
(plus 30 12) ; 42
(define lambda-plus (lambda (x y) (+ x y)))
(lambda-plus 30 12) ; 42
1
2
3
4
(define (plus x y) (+ x y))
(plus 30 12) ; 42
(define lambda-plus (lambda (x y) (+ x y)))
(lambda-plus 30 12) ; 42
copy to clipboard

In the Racket docu­men­ta­tion, func­tions are also called proce­dures. A func­tion that takes one argu­ment and returns a Boolean (like even? or empty?) is often called a pred­i­cate. You can test whether a value is a func­tion with the procedure? pred­i­cate.

Lambda is some­times used gener­i­cally as a synonym for func­tion, due to Racket’s asso­ci­a­tion with the lambda calculus. A lambda without argu­ments that wraps an expres­sion so it can be eval­u­ated later is some­times called a thunk.

Calling patterns

A func­tion can be invoked in two ways:

  1. Directly in an expres­sion. Any code written as a paren­the­sized expres­sion like (func arg1 arg2 ...) will be treated as a prefix-nota­tion func­tion call, where func is the func­tion name and arg1 arg2 ... are passed as its argu­ments.

    Though prefix nota­tion is most common, Racket supports a limited form of infix nota­tion in func­tion expres­sions. You can put the func­tion name between dots, and regard­less of where it appears, it will be treated as the first element of the expres­sion:

    (equal? gorilla-weight "800lb") ; prefix notation
    (gorilla-weight . equal? . "800lb") ; infix notation
    1
2
    (equal? gorilla-weight "800lb") ; prefix notation
(gorilla-weight . equal? . "800lb") ; infix notation
    copy to clipboard

  2. Indi­rectly, by passing it as an argu­ment to another func­tion. For example, apply takes a func­tion and a list of values like (list arg1 arg2 ...) and passes those values as argu­ments to the func­tion:

    (taller-than? alice bob) ; prefix notation
    (apply taller-than? (list alice bob)) ; `apply` notation
    1
2
    (taller-than? alice bob) ; prefix notation
(apply taller-than? (list alice bob)) ; `apply` notation
    copy to clipboard

    For another example, filter takes two argu­ments—a func­tion and a list of values—and applies the func­tion to each value, gener­ating a new list without the values that return #f:

    (filter even? (range 5)) ; '(0 2 4)
    1
    (filter even? (range 5)) ; '(0 2 4)
    copy to clipboard

    As mentioned above, you can always use a lambda expres­sion in place of a func­tion name:

    (filter (λ (x) (zero? (modulo x 2))) (range 5))
    ; also '(0 2 4)
    1
2
    (filter (λ (x) (zero? (modulo x 2))) (range 5))
; also '(0 2 4)
    copy to clipboard

    Func­tions that take other func­tions as argu­ments are known as higher-order func­tions. Other useful ones include map, andmap, ormap, compose1, and curry.

Input

A func­tion can be defined to accept any number of argu­ments, including zero. This number is the arity of the func­tion—a fancy word worth remem­bering, because you’ll see it in error messages:

(expt 2 4) ; 16
(expt 2 4 6) ; arity error, because `expt` takes only two args
1
2
(expt 2 4) ; 16
(expt 2 4 6) ; arity error, because `expt` takes only two args
copy to clipboard

By default, all func­tion argu­ments are posi­tional argu­ments, meaning they’re bound to iden­ti­fiers within the func­tion according to where they appear in the argu­ment list. Racket also supports named keyword argu­ments that can appear anywhere in the argu­ment list:

(define (sub x y) (- x y))
(sub 12 30) ; -18
(define (kw-sub #:foo foo-val y) (sub foo-val y))
(kw-sub 12 #:foo 30) ; 18
1
2
3
4
(define (sub x y) (- x y))
(sub 12 30) ; -18
(define (kw-sub #:foo foo-val y) (sub foo-val y))
(kw-sub 12 #:foo 30) ; 18
copy to clipboard

Any posi­tional or keyword argu­ment can have a default value by spec­i­fying that value in square brackets (as usual, argu­ments without default values must come first):

(define (add-defaults x [y 10] #:z [z 1]) (+ x y z))
(add-defaults 100 20) ; 121
(add-defaults 500) ; 511
1
2
3
(define (add-defaults x [y 10] #:z [z 1]) (+ x y z))
(add-defaults 100 20) ; 121
(add-defaults 500) ; 511
copy to clipboard

Func­tions can also be defined to take any number of argu­ments with a rest argu­ment, which means “put the rest of the argu­ments here”. A rest argu­ment always ends up holding a list. A rest argu­ment can be combined with other argu­ment types, but must appear last, and cannot have a default value:

(define (add-rest x . others) (apply + x others))
(add-rest 1 2 3 4 5 6 7 8 9 10) ; 55
1
2
(define (add-rest x . others) (apply + x others))
(add-rest 1 2 3 4 5 6 7 8 9 10) ; 55
copy to clipboard

In Racket, it’s common to use rest argu­ments when a func­tion can be logi­cally extended to take any number of argu­ments—even for oper­a­tions that in other languages take only two argu­ments:

(< 1 2 3 4 5 6 7 8 9 10) ; true
(/ 1 2 3 4 5 6 7 8 9 10) ; 1/3628800
1
2
(< 1 2 3 4 5 6 7 8 9 10) ; true
(/ 1 2 3 4 5 6 7 8 9 10) ; 1/3628800
copy to clipboard

If a declared rest argu­ment is unneeded, it becomes the empty list:

(define (f x . others)
  (println others))

(f 42) ; '()
1
2
3
4
(define (f x . others)
  (println others))

(f 42) ; '()
copy to clipboard

Output

Every func­tion has a return value. The value returned is the last value that appears in the func­tion. There is no return state­ment.

(define (adda x y) (+ x y) "boing")
(adda 30 12) ; "boing"
(define (addb x y) "boing" (+ x y))
(addb 30 12) ; 42
1
2
3
4
(define (adda x y) (+ x y) "boing")
(adda 30 12) ; "boing"
(define (addb x y) "boing" (+ x y))
(addb 30 12) ; 42
copy to clipboard

If the func­tion doesn’t have an explicit last value, then the constant #<void> is returned, which can be tested with void?. So #<void> is both a nothing and a some­thing:

(define (void-add x y) (when #f (+ x y)))
(void-add 30 12) ; nothing prints in REPL but ...
(void? (void-add 30 12)) ; true
1
2
3
(define (void-add x y) (when #f (+ x y)))
(void-add 30 12) ; nothing prints in REPL but ...
(void? (void-add 30 12)) ; true
copy to clipboard

It’s rarely neces­sary, but a func­tion can return multiple values, using values. These func­tions must be called from program posi­tions where multiple values are accepted (for instance, with define-values rather than define):

(define (two-vals x y) ; returns two values
  (values (+ x y) (* x y)))
; `define-values` accepts two return values
(define-values (sum prod) (two-vals 11 3))
(list sum prod) ; '(14 33)
; error: `define` accepts only one return value
(define both (two-vals 11 3))
1
2
3
4
5
6
7
(define (two-vals x y) ; returns two values
  (values (+ x y) (* x y)))
; `define-values` accepts two return values
(define-values (sum prod) (two-vals 11 3))
(list sum prod) ; '(14 33)
; error: `define` accepts only one return value
(define both (two-vals 11 3))
copy to clipboard

For this reason, if you’re thinking of using values, consider first whether you could plau­sibly return your results inside a single pair or list or struc­ture type, as those tend to be more conve­nient.

Naming conven­tions

Within the Racket library, certain sets of func­tions have special naming conven­tions. Adopting these conven­tions for your own code isn’t manda­tory, but knowing them will help you under­stand existing Racket code, and using them will help others under­stand yours:

Func­tional program­ming

Racket belongs to a cate­gory of languages—also including Scheme, Common Lisp, and Haskell—that are asso­ci­ated with func­tional program­ming. Func­tional program­ming is a style of program­ming where func­tions receive certain data as input, process only that data, and return a result. (It does not mean “program­ming with func­tions”—everyone does that.)

In func­tional program­ming, program­mers avoid two habits common in other languages: muta­tion (= changing data in-place rather than returning a value) and relying on state (= extra context that’s not provided as input, for instance global vari­ables).

Without state and muta­tion, the behavior of each func­tion is contained. Thus, it’s easier to prove things about that behavior—in the research sense (if you’re a computer scien­tist) or in the testing sense (if you’re a programmer).

That said, there are times where the func­tional-program­ming approach doesn’t fit, espe­cially with func­tions that are used for their side effects—for instance, println. So the rule of thumb in Racket is to use func­tional program­ming when you can, and depart from it when you must.

Further

← prev next →