racket
Rekursion

Using definieren

#lang racket
(define (sum-of-list l)
  (if (null? l)
      0
      (+ (car l)
         (sum-of-list (cdr l)))))
(sum-of-list '(1 2 3 4 5)) ;; => 15

Let-rec verwenden

#lang racket
(letrec ([sum-of-list (λ (l)
                        (if (null? l)
                            0
                            (+ (car l) (sum-of-list (cdr l)))))])
  (sum-of-list '(1 2 3 4 5)))
;; => 15

Mit letrec gegenseitig rekursive Funktionen letrec :

#lang racket
(letrec ([even? (λ (n) (if (= n 0) #t (odd?  (sub1 n))))]
         [odd?  (λ (n) (if (= n 0) #f (even? (sub1 n))))])
  (list (even? 3)
        (odd? 5)))
;; => '(#f #t)

Benannte ein Let

Ein normales let Formular bindet jeden Wert an seinen entsprechenden Bezeichner, bevor der Body ausgeführt wird. Mit einem "named let " kann der Body rekursiv erneut ausgeführt werden, wobei für jeden Bezeichner ein neuer Wert übergeben wird.

#lang racket
(let sum-of-list ([l '(1 2 3)])
  (if (null? l)
      0
      (+ (car l) (sum-of-list (cdr l)))))
;; => 15

Es ist üblich, rec als Namen für das let zu verwenden, was Folgendes ergibt:

#lang racket
(let rec ([l '(1 2 3 4 5)])
  (if (null? l)
      0
      (+ (car l) (rec (cdr l)))))
;; => 15

Verwenden von rec

#lang racket
(require mzlib/etc)
((rec sum-of-list
   (λ (l)
     (if (null? l)
         0
         (+ (car l) (sum-of-list (cdr l))))))
 '(1 2 3 4 5))
;; => 15

;; Outside of the rec form, sum-of-list gives an error:
;; sum-of-list: undefined;
;;  cannot reference an identifier before its definition

Dies ist ähnlich zu define , aber die sum-of-list - Identifizierer sind außerhalb der nicht sichtbar rec Form.

Um die Verwendung eines expliziten λ zu vermeiden, ist es möglich, die sum-of-list durch (sum-of-list args ...) zu ersetzen:

#lang racket
(require mzlib/etc)
((rec (sum-of-list l)
   (if (null? l)
       0
       (+ (car l) (sum-of-list (cdr l)))))
 '(1 2 3 4 5))
;; => 15

Verwenden von Funktionen höherer Ordnung statt Rekursion

Es ist üblich, anstelle von Rekursion Funktionen höherer Ordnung zu verwenden, wenn es eine Funktion höherer Ordnung gibt, die das richtige Rekursionsmuster darstellt. In unserem Fall kann die sum-of-numbers mit foldl definiert werden:

#lang racket
(define (sum-of-numbers l)
  (foldl + 0 l))
(sum-of-numbers '(1 2 3 4 5)) ;; => 15

Es ist möglich, foldl direkt in der Liste foldl :

#lang racket
(foldl + 0 '(1 2 3 4 5)) ;; => 15