Binary Search in Lisp (racket-lang)

Binary search

#lang racket

(define (get-list l n) 
  (if (= n 0)
      (car l)
      (get-list (cdr l) (- n 1))))

(define (r-gen l n range) 
  (if (= n 1)
    (r-append l range)
    (r-gen (r-append l range) (- n 1) range)))
             
(define (r-append l r)
  (let ((r-num (random r)))
    (if (num-exists? l r-num)
        (r-append l r)
        (append l (list r-num))))) 

(define (num-exists? l f)
  (if (find-num l f (length l))
      #t #f))

(define (find-num l f len)
  (let ((idx (- len 1))) 
    (if (< idx 0)
      #f
      (if (= (get-list l idx) f)
          #t
          (find-num l f idx)))))

(define (<sort l)
  (let ((end (length l)))
  (begin
  (for ( [i (build-list end values)] )
    (for ( [j (build-list end values)] )
      (if (< (get-list l i) (get-list l j))     
           (set! l (swap l i j))
         null))) l)))

(define (add-til l s til) 
  (if (< s til)
    (append (list (get-list l s)) (add-til l (+ s 1) til))
    null))

(define (swap l i j) 
  (if (> i j)
    (slicer l j i)
    (slicer l i j)
  )
)
(define (slicer l i j)
   (let ((tmp (get-list l j)) (sw (get-list l i)))
      (append (add-til l 0 i) (list tmp) (add-til l (+ i 1) j) (list sw) (add-til l (+ j 1) (length l)))
     ))

(define (binary-search search-list find-num s e)
  (let* ((start s) (end e) (mid (round (/ (+ start end) 2))) (compare (get-list search-list mid)))
     (if (< end start)
       (display (cons "it dosen't exists" "\n"))
       (if (> (get-list search-list mid) find-num)
         (binary-search search-list find-num start (- mid 1))
         (if (< (get-list search-list mid) find-num)
           (binary-search search-list find-num (+ mid 1) end)
           (display (cons "it exists" "\n"))
         )
       )
     )
   ))


(define (bs l f s e) 
  (if (and (>= f (get-list l s)) (<= f (get-list l e)))
    (binary-search l f s e)
    (display "it is out of range.")))

;Start program


(define generated (r-gen (list) 20 100))

(display (cons "Generated random number :" generated))

(display "\n")

(define sorted (<sort generated))

(display (cons "Sorted number :" sorted))

(display "\n")

(display "What do you looking for ? (Exit:: type at least 101)")

(define (bsearch r)
    (begin 
      (set! r (read))
      (if (> r 100) 
        (display "Program exit;")
        (begin 
          (bs sorted r 0 (- (length sorted) 1))
          (bsearch 101)
        )
      )
    )
)

(bsearch 101)