;; NOTE: All the equal?? tests should be uncommented in the final homework
;;       submission, **AND** you should add at least one more equal?? test 
;;       for each problem.

;; CIS 352 Homework 2
;; Author: FILL_IN
;; Author: FILL_IN

(require "utils.scm")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Problem 1: (12 points) EOPL, Exercise 1.16
;; invert : list-of-2-lists -> list-of-2-lists
;; (invert lst) 
;;     returns ...
(define invert
  (lambda (ps)
    ps)) ;; CHANGE!!
  
  
;; tests
;(equal?? (invert '()) 
;         '())
;(equal?? (invert '((a 1) (a 2) (1 b) (2 b))) 
;         '((1 a) (2 a) (b 1) (b 2)))
;(equal?? (invert '((foo (boo moo))))
;         '(((boo moo) foo)))
(report-unit-tests-completed 'invert)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Problem 2: (16 points) EOPL, Exercise 1.18
;; swapper : Symbol * Symbol * S-list -> S-list
;; (swapper s1 s2 slist)
;;     returns ...
(define swapper 
  (lambda (s1 s2 slist)
    slist)) ;; CHANGE

;; tests
;(equal?? (swapper 'a 'd '())
;         '())
;(equal?? (swapper 'a 'd '(a b c d))
;         '(d b c a))
;(equal?? (swapper 'a 'd '(a d () c d))
;         '(d a () c a))
;(equal?? (swapper 'x 'y '((x) y (z (x))))
;         '((y) x (z (y))))
;
(report-unit-tests-completed 'swapper)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Problem 3: (16 points) EOPL, Exercise 1.21
;; product : list-of-symbols * list-of-symbols -> list
;; (product sos1 sos2) 
;;     returns ...  
(define product 
  (lambda (sos1 sos2)
    '()))  ;; CHANGE!

;; tests
;(equal?? (product '(a b c) '())
;         '())
;(equal?? (product '() '(x y))
;         '())
;(equal?? (product '(a b c) '(x y))
;         '((a x) (a y) (b x) (b y) (c x) (c y)))
(report-unit-tests-completed 'product)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Problem 4: (12 points) EOPL, Exercise 1.22
;; index-list : predicate * list -> number
;; (index-list pred lst)  
;;      returns ...
  
(define index-list
  (lambda (pred lst)
    #f)) ;; CHANGE!

;; tests
;(equal?? (index-list number? '(a 2 (1 3) b 7))
;         1)
;(equal?? (index-list number? '(a #t (1 3) b 7))
;         4)
;(equal?? (index-list symbol? '(a (b c) 17 foo))
;         0)
;(equal?? (index-list symbol? '(1 2 (a b) 3))
;         #f)
(report-unit-tests-completed 'index-list)




;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Problem 5: (12 points) EOPL, Exercise 1.24
;; every? : predicate * list -> boolean
;; (every? pred lst)  
;;      returns ...
  
(define every?
  (lambda (pred lst)
    #f)) ;; CHANGE!
  
;; tests
;(equal?? (every? number? '(1 b c 3 e))
;         #f)
;(equal?? (every? number? '(1 2 3 4 5))
;         #t)
;(equal?? (every? symbol? '())
;         #t)
(report-unit-tests-completed 'every?)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Problem 6: (16 points) EOPL, Exercise 1.27
;; index-list : predicate * list -> number
;; (index-list pred lst)  
;;      returns ...
  
(define flatten
  (lambda (slist)
    '())) ;; CHANGE!

;; tests
;(equal?? (flatten '(a b c))
;         '(a b c))
;(equal?? (flatten '((a) () (b ()) () (c)))
;         '(a b c))
;(equal?? (flatten '((a b) c (((d)) e)))
;         '(a b c d e))
;(equal?? (flatten '(a b (() (c))))
;         '(a b c))
;(equal?? (flatten '())
;        '())
(report-unit-tests-completed 'flatten)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Problem 7: (16 points) compose-all
;; compose-all : list-of-procs -> proc
;; (compose-all pred1 ... predn)  
;;      returns ...
  

(define compose-all
  (lambda procs
    (lambda (x)
      'periwinkles))) ;; CHANGE!

;; tests
;(define plus1 (lambda (x) (+ x 1))) 
;(define times10 (lambda (y) (* y 10))) 
;
;(equal?? ((compose-all car cdr cdr cdr) '(a b c d e f g))
;	 (cadddr '(a b c d e f g)))
;(equal?? ((compose-all times10 times10 plus1 plus1) 3) 
;         500)
;(equal?? ((compose-all) 17)
;         17)
(report-unit-tests-completed 'compose-all)