Some functions' custom implementations in scheme

functional.scm

(define (my-map f l)
  (if (eq? l '())
	  '()
	  (cons (f (car l)) (my-map f (cdr l)))))

(print (my-map (lambda (x) (+ 1 x)) '(1 2 3)))

(define (my-reverse l acc)
  (if (eq? l '())
	  acc
	  (my-reverse (cdr l) (cons (car l) acc))))

(define (my-rev l)
  (my-reverse l '()))

(print (my-rev '(1 2 3 4 5)))

(define (my-filter p l)
  (if (eq? l '())
      '()
      (let ((curr (car l)))
        (if (p curr)
            (cons curr (my-filter p (cdr l)))
            (my-filter p (cdr l))))))

(print (my-filter even? '(1 2 3 4 5 6 7 8 9 10)))
(print (my-filter odd? '(1 2 3 4 5 6 7 8 9 10)))

(define (my-fold acc f l)
  (if (eq? l '())
      acc
      (my-fold (f acc (car l)) f (cdr l))))

(print (my-fold 0 + '(1 2 3 4 5)))

(define (my-foldr acc f l)
  (if (eq? l '())
      acc
      (f (my-foldr acc f (cdr l)) (car l))))

(print (my-foldr 0 + '(1 2 3 4 5)))
(print (my-foldr '() cons '(1 2 3 4 5)))
(print (my-foldr 5 / '(1 2 3 4)))
(print (my-fold 1 / '(2 3 4 5)))

(define (my-take l n)
  (if (or (eq? l '()) (= n 0))
      '()
      (cons (car l) (my-take (cdr l) (- n 1)))))

(print (my-take '(1 2 3 4 5) 3))

(define (my-drop l n)
  (if (or (eq? l '()) (= n 0))
      l
      (my-drop (cdr l) (- n 1))))

(print (my-drop '(1 2 3 4 5) 2))

(define (my-every? f l)
  (if (eq? l '())
      #t
      (and (f (car l)) (my-every? f (cdr l)))))

(print (my-every? even? '(2 4 6 8)))
(print (my-every? even? '(2 4 6 7)))
(print (my-every? odd? '(2 4 6 7)))
(print (my-every? odd? '(1 3 5 7)))

(define (my-any? f l)
  (if (eq? l '())
      #f
      (or (f (car l)) (my-any? f (cdr l)))))

(print (my-any? even? '(1 3 5 2)))
(print (my-any? even? '(1 3 5 7)))
(print (my-any? odd? '(2 4 6 7)))
(print (my-any? odd? '(2 4 6 8)))

(define (my-quick-sort l)
  (if (eq? l '())
      '()
      (let ((pivot (car l))
            (rest  (cdr l)))
        (append
          (my-quick-sort
            (filter (lambda (x) (< x pivot)) rest))
          (list pivot)
          (my-quick-sort
            (filter (lambda (x) (>= x pivot)) rest))))))

(print (my-quick-sort '(5 6 3 1 8 3 7)))