[doc]/guide/scheme-forms.html proseguendo da qui.
A basic definition has the form
(define id expr)
in which case
id is bound to the result of
define form also supports a shorthand for function definitions:
(define (id arg ...) body ...+)
which is a shorthand for
(define id (lambda (arg ...) body ...+))
The function shorthand via
define also supports a rest argument (i.e., a final argument to collect extra arguments in a list):
(define (id arg ... . rest-id) body ...+)
which is a shorthand
(define id (lambda (arg ... . rest-id) body ...+))
Adesso sono nei guai: non so tradurre curry, specie quando declinato come aggettivo, portate pazienza :roll:
Poi, ripensandoci, lascio in inglese, tanto c’è lo spiegone.
Consider the following
make-add-suffix function that takes a string and returns another function that takes a string:
Although it’s not common, result of
make-add-suffix could be called directly, like this:
In a sense,
make-add-suffix is a function takes two arguments, but it takes them one at a time. A function that takes some of its arguments and returns a function to consume more is sometimes called a curried function.
Using the function-shorthand form of
make-add-suffix can be written equivalently as
This shorthand reflects the shape of the function call
(make-add-suffix "!"). The define form further supports a shorthand for defining curried functions that reflects nested function calls:
The full syntax of the function shorthand for define is as follows:
(define (head args) body ...+) head = id | (head args) args = arg ... | arg ... . rest-id
The expansion of this shorthand has one nested
lambda form for each head in the definition, where the innermost head corresponds to the outermost
Valori multipli e
A Racket expression normally produces a single result, but some expressions can produce multiple results. For example,
remainder each produce a single value, but
quotient/remainder produces the same two values at once:
As shown above, the REPL prints each result value on its own line.
Multiple-valued functions can be implemented in terms of the values function, which takes any number of values and returns them as the results:
define-values form binds multiple identifiers at once to multiple results produced from a single expression:
(define-values (id ...) expr)
The number of results produced by the
expr must match the number of
define form (that is not a function shorthand) is equivalent to a
define-values form with a single
Qui entriamo in una cosa lispica che a prima vista sembra difficile ma è quello che rende pheego il Lisp (e derivati).
When the grammar for a syntactic form specifies body, then the corresponding form can be either a definition or an expression. A definition as a body is an internal definition.
Expressions and internal definitions in a body sequence can be mixed, as long as the last body is an expression.
For example, the syntax of
(lambda (f) ; no definitions (printf "running\n") (f 0)) (lambda (f) ; one definition (define (log-it what) (printf "~a\n" what)) (log-it "running") (f 0) (log-it "done")) (lambda (f n) ; two definitions (define (call n) (if (zero? n) (log-it "done") (begin (log-it "running") (f n) (call (- n 1))))) (define (log-it what) (printf "~a\n" what)) (call n))
so the following are valid instances of the grammar:
(lambda gen-formals body ...+)
Internal definitions in a particular body sequence are mutually recursive; that is, any definition can refer to any other definition—as long as the reference isn’t actually evaluated before its definition takes place. If a definition is referenced too early, an error occurs.
A sequence of internal definitions using just
define is easily translated to an equivalent
letrec form ([prossimamente]). However, other definition forms can appear as a body, including
struct ([prossimamente]) or
Pausa (ci vuole, imho) :mrgreen: