racket
प्रत्यावर्तन

परिभाषित का उपयोग करना

#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

लेट-रेक का उपयोग करना

#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 साथ परस्पर पुनरावर्ती कार्यों को लिखना संभव है:

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

नामित नाम का उपयोग करना

शरीर को निष्पादित करने से पहले, एक सामान्य let फ़ॉर्म प्रत्येक संबंधित मान को उसके संबंधित आइडेंटिफायर से बांधता है। एक "नाम let " के साथ, शरीर को फिर से पुन: निष्पादित किया जा सकता है, प्रत्येक पहचानकर्ता के लिए एक नया मान गुजरता है।

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

लेट के लिए नाम के रूप में rec का उपयोग करना आम है, जो देता है:

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

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

यह define करने के समान है, लेकिन rec -फॉर्म के बाहर sum-of-list पहचानकर्ता दिखाई नहीं देता है।

एक स्पष्ट λ का उपयोग करने से बचने के लिए, sum-of-list को (sum-of-list args ...) साथ बदलना संभव है (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

पुनरावृत्ति के बजाय उच्च-क्रम के कार्यों का उपयोग करना

पुनरावृत्ति के बजाय उच्च आदेश कार्यों का उपयोग करना आम बात है, यदि उच्च क्रम फ़ंक्शन है जो सही पुनरावर्तन पैटर्न को व्यक्त करता है। हमारे मामले में, sum-of-numbers का उपयोग कर परिभाषित किया जा सकता foldl :

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

सूची पर सीधे foldl कॉल करना संभव है:

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