racket
Rekurencja

Korzystanie z definicji

#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

Korzystanie z let-rec

#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

letrec pomocą letrec można pisać wzajemnie rekurencyjne funkcje:

#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)

Używanie nazwanego let

Normalny formularz let wiąże każdą wartość z odpowiednim identyfikatorem przed wykonaniem treści. Dzięki „nazwie let ” ciało może być rekurencyjnie ponownie wykonane, przekazując nową wartość dla każdego identyfikatora.

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

Powszechnie używa się rec jako nazwy let, co daje:

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

Korzystanie z 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

Jest to podobne do define , ale identyfikator sum-of-list nie jest widoczny poza formularzem rec .

Aby uniknąć używania jawnego λ , możliwe jest zastąpienie sum-of-list (sum-of-list args ...) :

#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

Używanie funkcji wyższego rzędu zamiast rekurencji

Powszechną praktyką jest używanie funkcji wyższego rzędu zamiast rekurencji, jeśli istnieje funkcja wyższego rzędu, która wyraża właściwy wzorzec rekurencji. W naszym przypadku sum-of-numbers można zdefiniować za pomocą funkcji foldl :

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

Możliwe jest wywołanie foldl bezpośrednio na liście:

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