;; ****************************************
;; *  Csu 211 : 2/27/2008
;; *  Lecture #20 Code
;; *  Functions As Values
;; ****************************************

(define percents '(60.0 80.0 76.6 76.6 75.0 83.3 35.0 81.6 91.6 55.0 71.6 81.6
                        30.0 71.6 83.3 70.0 71.6 66.6 78.3 13.3 80.0 78.3 71.6
                        91.6 96.6 78.3 51.6 86.6 61.6 78.3 95.0 71.6 80.0 75.0
                        66.6 85.0 63.3 80.0 63.3 71.6 88.3 56.6 71.6 76.6))

;; mylength: (listof X) -> Number
;; Calculate the Length of the given list
(define (mylength lo)
  (cond [(empty? lo) 0]
        [(cons? lo) (+ 1 (mylength (rest lo)))]))

;; A Single is: (make-single Number)
(define-struct single (n))

(check-expect (mylength empty) 0)
(check-expect (mylength '((3 1) (5 2) (5 7))) 3)
(check-expect (mylength (list (make-single 3) (make-single 8)
                              (make-single 5) (make-single 10))) 4)


;; l-general: (listof X) (X -> Y) (W Y Z -> Z) Z W (W -> W) ==> Z
;; Do something with a bunch of functions...
(define (l-general l what doit justdoit money update-money)
  (cond [(empty? l) justdoit]
        [(cons? l)
         (doit money (what (first l))
               (l-general (rest l) what doit justdoit
                          (update-money money) update-money))]))

;; fix: Number -> Number
;; Fix a number for the reverse Y coord if the screen
(define (fix n)
  (- 400 (* 4 n)))

;; magic: Number Scene -> Scene
;; Draw one point into a scene
(define (magic x y scn)
  (place-image (circle 5 'solid 'magenta)
               x y scn))

;; add-8: Number -> Number
(define (add-8 n)
  (+ 8 n))

;; lon-scene: LON -> Scene
;; Plot a LON into a Scene using the general function
;; For this specific use, l-general has the type of:
;;    (listof Number) (Number -> Number) (Number Scene -> Scene)
;;                               Scene Number (Number -> Number) ==> Scene
(define (lon-scene l scn)
  (l-general l fix magic scn 30 add-8))

;; insert: (listof X) X (X X -> Boolean) -> (listof X)
;; Insert a given X into the sorted list, using comp to compare elements
(define (insert l x comp)
  (cond [(empty? l) (list x)]
        [(comp x (first l)) (cons x l)]
        [else (cons (first l) (insert (rest l) x comp))]))

;; sort: (listof X) (X X -> Boolean)
;; Sort a (listof X) based on the comparison function comp
(define (sort l comp)
  (cond [(empty? l) empty]
        [else (insert (sort (rest l) comp) (first l) comp)]))

;; Some Tests
(check-expect (sort '(4 1 6 3 5 5 2 3 4) >) '(6 5 5 4 4 3 3 2 1))
(check-expect (sort '(4 1 6 3 5 5 2 3 4) <=) '(1 2 3 3 4 4 5 5 6))

;; Overlay both 'sorts' of the exam grades...
(lon-scene (sort percents <) 
           (lon-scene (sort percents >) (empty-scene 400 400)))


;; something: (Number or Single) -> Number
;; Pull the number out of a single, or just return the given number
(define (something n)
  (cond [(single? n) (single-n n)]
        [else n]))

;; l-lessgeneral: (listof X) (X -> Y) (Y Z -> Z) Z ==> Z
;; Do something with a bunch of functions...
(define (l-lessgeneral l what doit justdoit)
  (cond [(empty? l) justdoit]
        [(cons? l)
         (doit (what (first l))
               (l-lessgeneral (rest l) what doit justdoit))]))


;; l-prod: (listof Number-or-Single) -> Number
;; Calculate the Product of all the numbers in the list
(define (l-prod l)
  (l-lessgeneral l something * 1))

;; l-sum: (listof Number-or-Single) -> Number
;; Calculate the Sum of all the numbers in the list
(define (l-sum l)
  (l-lessgeneral l something + 0))

;; l-add1: LON -> LON
;; Add 1 to each element of the given list
(define (l-add1 l)
  (l-lessgeneral l add1 cons empty))

(check-expect (l-prod '(1 2 5 3 4)) 120)
(check-expect (l-prod (list (make-single 1) (make-single 2)
                            (make-single 5) (make-single 3)
                            (make-single 4))) 120)
          
(check-expect (l-sum '(1 2 5 3 4)) 15)
(check-expect (l-sum (list (make-single 1) (make-single 2)
                           (make-single 5) (make-single 3)
                           (make-single 4))) 15)

(check-expect (l-add1 '(1 2 5 3 4)) '(2 3 6 4 5))

(generate-report)