Quicksort, lisp

(define sum (lambda (xs) (sum_h xs 0)))
(define sum_h (lambda (xs x) (cond
    ((equal? xs '())
        x
    )
    (#t
        (sum_h (cdr xs) (+ x (car xs)))
    )
    )
))
(define range (lambda (n m) (range_h n m '())))
(define range_h (lambda (n m xs) (cond
    ((>= n (+ m 1))
        xs
    )
    (#t
        (range_h  n  (- m 1) (cons m xs))
    )
    )
))
(define rangestep (lambda (n m x) (rangestep_h n m x '())))
(define rangestep_h (lambda (n m x xs) (cond
    ((>= n (+ m 1))
        xs
    )
    (#t
        (rangestep_h (+ n x) m x (append xs (list n)))
    )
    )
))
(define part (lambda (fu xs) (part_h fu xs '() '())))
(define part_h (lambda (fu xs xss xsn) (cond
    ((equal? xs '())
        (list xss xsn)
    )
    (#t
        (cond
            ((fu (car xs))
                (part_h fu (cdr xs) (append xss (list (car xs))) xsn)
            )
            (#t
                (part_h fu (cdr xs) xss (append xsn (list (car xs))))
            )
        )
    )
    )
))
(define filter (lambda (fu xs) (filter_h fu xs '())))
(define filter_h (lambda (fu xs xss) (cond
    ((equal? xs '())
        xss
    )
    (#t
        (cond
            ((fu (car xs))
                (filter_h fu (cdr xs) (append xss (list (car xs))))
            )
            (#t
                (filter_h fu (cdr xs) xss)
            )
        )
    )
    )
))
(define quicksort (lambda(xs) (cond
    ((equal? xs '())
        '()
    )
    (#t
        (let ((v (car xs)))
            (let ((prt (part (lambda (n) (< n v)) (cdr xs))))
                (let ((lss (car prt))  (mre (car (cdr prt))))
                    (append
                        (quicksort lss)
                        (list v)
                        (quicksort mre)
                    )
                )
            )
        )
    )
    )
))
(let ((li (map (lambda(n) (- n)) (range 0 10))) )
(display li)
(newline)
(display  (quicksort li))
)