racket
Herhaling

Gebruik definiëren

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

#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

Het is mogelijk om wederzijds recursieve functies te schrijven met 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)

Een benoemde let gebruiken

Een normale let vorm bindt elke waarde aan zijn overeenkomstige identificatie, voordat de body wordt uitgevoerd. Met een "genaamd let " kan de body vervolgens recursief opnieuw worden uitgevoerd, waarbij een nieuwe waarde voor elke identificatie wordt doorgegeven.

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

Het is gebruikelijk om rec te gebruiken als de naam voor de let, die geeft:

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

Gebruik 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

Dit is vergelijkbaar met define , maar de sum-of-list ID is niet zichtbaar buiten het rec formulier.

Om te voorkomen dat een expliciete λ , is het mogelijk om de sum-of-list te vervangen door (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

Hogere-orde functies gebruiken in plaats van recursie

Het is gebruikelijk om hogere orde functies te gebruiken in plaats van recursie, als er een hogere orde functie is die het juiste recursiepatroon uitdrukt. In ons geval kan de sum-of-numbers worden gedefinieerd met behulp van foldl :

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

Het is mogelijk om foldl rechtstreeks foldl de lijst te bellen:

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