```;; Zip the two lists lst1 and lst2 by means of z.     (define (zip z lst1 lst2)
(if (null? lst1)
'()
(cons
(z (car lst1) (car lst2))
(zip z (cdr lst1) (cdr lst2)))))

;; Compose a list of functions to a single function.
;; Each function in the list takes a single parameter.
;; Handles the typical case of two functions manually to achieve
;; better efficiency.
;; .precondition f-list is a proper list of length ast least one.      (define (compose . f-list)
(cond ((= 1 (length f-list)) (car f-list)) ;          ((= 2 (length f-list)) ;  	 (let ((f (car f-list))
(lambda (x) (f (g x)))))
(else  (lambda (x)     ;  		 ((car f-list)
((apply compose (cdr f-list)) x))))))

;; Filter lst by pred.     (define (filter pred lst)
(reverse ;    (filter-help pred lst '())))

; The function that does the real filtering.
; A tail recursive function     (define (filter-help pred lst res)
(cond ((null? lst) res)
((pred (car lst))
(filter-help pred (cdr lst)  (cons (car lst) res)))
(else
(filter-help pred (cdr lst)  res))))

;; Generate a less than or equal predicate from the enumeration-order.
;; If p is the generated predicate, (p x y) is true if and only if
;; (selector x) comes before (or at the same position) as (selector y)
;; in the enumeration-order. Thus, (selector x) is assumed to give a
;; value in enumeration-order. Comparison with elements in the enumeration-list
;; is done with el-eq?
;; .form (generate-leq enumeration-order selector [el-eq?])     (define (generate-leq enumeration-order selector . optional-parameter-list)
(let ((el-eq? (optional-parameter 1 optional-parameter-list eq?)))
(lambda (x y)
; x and y supposed to be elements in enumeration order     (let ((x-index (list-index (selector x) enumeration-order el-eq?))
(y-index (list-index (selector y) enumeration-order el-eq?)))
(<= x-index y-index)))))

; A helping function of generate-leq.
; Return the position of e in lst. First is 1
; compare with el-eq?
; if e is not member of lst return (+ 1 (length lst))     (define (list-index e lst el-eq?)
(cond ((null? lst) 1)
((el-eq? (car lst) e) 1)
(else (+ 1 (list-index e (cdr lst) el-eq?)))))

; A list of functions from the other souce program   (define other-source-list
(list fac head tail))
```