Exemple

Cet exemple montre une réalisation possible d'une fonction de tri. Ses arguments sont un vecteur dont les éléments sont à trier par rapport à une fonction de comparaison, elle aussi en argument.

Cette fonction montre une utilisation conjointe des formes let, let* et do.

La fonction sort parcourt l'ensemble des éléments du vecteur, du premier au dernier. Elle parcourt alors les éléments à partir du dernier, en comparant avec la fonction compare l'élément courant à l'élément précédent. S'il est plus petit, il est déplacé :

(define (sort vec compare)
 ; test des argumenents
 (if (and (vector?    vec)
          (procedure? compare))
   ; variables locales
   (let* ([len   (vector-length vec)]
          [len-1 (- len 1)])
    ; parcourt de premier au dernier
    (let loop-i ([i 0])
     (if (>= i len-1)
       ; la fin est atteinte ; retourner le vecteur
       vec
       (begin
        ; parcourt du dernier vers le courant
        (do ([j len-1 (- j 1)])
            ((<= j i))
          (let ([j-1 (- j 1)])
           ; comparaison
           (if (compare (vector-ref vec j)
                        (vector-ref vec j-1))
             ; plus petit~: décalage
             (let ([temp (vector-ref vec j)])
              (vector-set! vec 
                           j
                           (vector-ref vec j-1))
              (vector-set! vec 
                           j-1
                           temp)))))
        ; continuer sur le reste des éléments
        (loop-i (+ i 1))))))
   ; les arguments sont invalides
   #f))

Utilisons cette fonction pour trier des vecteurs :

Osm> (display (sort #(1 3 2 4 6 5 0) <))
     (newline)
  => #(0 1 2 3 4 5 6)

Osm> (display (sort #(1 3 2 4 6 5 0) >))
     (newline)
  => #(6 5 4 3 2 1 0)

Osm> (display (sort #("dsd" "aa" "sde") string>?))
     (newline)
  => #("sde" "dsd" aa")

Ainsi, l'utilisateur peut trier ses propres structures de données avec cette fonction si elles peuvent être ordonnées à l'aide de la fonction de comparaison compare passée en argument qui traduit la relation d'ordre des éléments du tableau.