;; my-foldr : [X Y -> Y] Y [Listof X] -> Y
;; (last lecture, we called this process)
(define (my-foldr op base lox) 
  (cond [(empty? lox) base]
        [else (op (first lox) 
                  (my-foldr op base (rest lox)))]))

;; sum : LON -> Number
;; compute sum of all numbers in given list
(define (sum lon)
  (my-foldr + 0 lon))

;; product : LON -> Number
;; computer product of all numbers in given list
(define (product lon)
  (my-foldr * 1 lon))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PROBLEM: 
;; Design a function that takes a list of numbers representing radii of 
;; circles and draws red concentric circles with those radii on an empty
;; scene.  Use foldr

;; draw-circles : [Listof Number] -> Image
;; draw red concentric circles of given radii (represented by the 
;; numbers in lon) in center of an empty scene
#;(define (draw-circles lon)
  (cond [(empty? lon) (empty-scene 100 100)]
        [else (overlay (circle (first lon) "outline" "red")
                       (draw-circles (rest lon)))]))
  
;; draw-circles : [Listof Number] -> Image
(define (draw-circles lon)
  (foldr add-circ (empty-scene 100 100) lon))

;; add-circ : Number Image -> Image
(define (add-circ n img)
  (overlay (circle n "outline" "red") img))


(check-expect (draw-circles empty) (empty-scene 100 100))
(check-expect (draw-circles '(5 10)) 
              (overlay (circle 5 "outline" "red")
                       (overlay (circle 10 "outline" "red")
                                (empty-scene 100 100))))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; all+1 : [Listof Number] -> [Listof Number]
;; add one to every element of lon and return list of answers
#;(define (all+1 lon)
  (cond [(empty? lon) empty]
        [else (cons (add1 (first lon))
                    (all+1 (rest lon)))]))

;; all-lengths : [Listof String] -> [Listof Number]
;; compute lengths of every (string) element of los and return list of answers
#;(define (all-lengths los)
  (cond [(empty? los) empty]
        [else (cons (string-length (first los))
                    (all-lengths (rest los)))]))

;; my-map : [X -> Z] [Listof X] -> [Listof Z]
(define (my-map op lox)
  (cond [(empty? lox) empty]
        [else (cons (op (first lox))
                    (my-map op (rest lox)))]))

;; all+1 : [Listof Number] -> [Listof Number]
;; add one to every element of lon and return list of answers
(define (all+1 lon)
  (my-map add1 lon))
;; instantiating X = Number and Z = Number in signature of my-map

;; all-lengths : [Listof String] -> [Listof Number]
;; compute lengths of every (string) element of los and return list of answers
(define (all-lengths los)
  (my-map string-length los))
;; instantiating X = String and Z = Number in signature of my-map

(check-expect (all+1 empty) empty)
(check-expect (all+1 '(3 2 40)) '(4 3 41))

(check-expect (all-lengths empty) empty)
(check-expect (all-lengths '("hello" "northeastern")) '(5 12))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; nums-to-lons : [Listof Number] -> [Listof [Listof Number]]
;; put each number in lon in a 1-element list and return list of these 
;; e.g., (list 1 3) ---> (list (list 1) (list 3))
#;(define (nums-to-lons lon)
  (cond [(empty? lon) empty]
        [else (cons (list (first lon))
                    (nums-to-lons (rest lon)))]))

;; nums-to-lons : [Listof Number] -> [Listof [Listof Number]]
;; put each number in lon in a 1-element list and return list of these 
;; e.g., (list 1 3) ---> (list (list 1) (list 3))
(define (nums-to-lons lon)
  (my-map list lon))
;; plug in X = Number  Z = [Listof Number]

(check-expect (nums-to-lons empty) empty)
(check-expect (nums-to-lons (list 1 3)) (list (list 1) (list 3)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; y-of-posns : [Listof Posn] -> [Listof Number]
;; given an list of posns, extract the y coord of each posn in lop
#;(define (y-of-posns lop)
  (cond [(empty? lop) empty]
        [else (cons (posn-y (first lop))
                    (y-of-posns (rest lop)))]))

;; y-of-posns : [Listof Posn] -> [Listof Number]
;; given an list of posns, extract the y coord of each posn in lop
(define (y-of-posns lop)
  (my-map posn-y lop))

(check-expect (y-of-posns empty) empty)
(check-expect (y-of-posns (list (make-posn 1 3)
                                (make-posn 20 10))) 
              (list 3 10))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; greater-than-5s : [Listof Number] -> [Listof Boolean]
;; for each n in lon, is n > 5?; return answers in a list
#;(define (greater-than-5s lon)
  (cond [(empty? lon) empty]
        [else (cons (> (first lon) 5)
                    (greater-than-5s (rest lon)))]))
 
;; Now define greater-than-5s using my-map...

;; Number -> Boolean
(define (>5? n)
  (> n 4))
  
;; greater-than-5s : [Listof Number] -> [Listof Boolean]
;; given a list of numbers produce boolean list that says whether 
;; each element is >5 or not
(define (greater-than-5s lon)
  (local (;; Number -> Boolean
          ;; Is n > 5 ?
          (define (>5? n) (> n 5)))
    (map >5? lon)))

(check-expect (greater-than-5s '(6 4 5 10))
              (list true false false true))


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Number -> Number
(define (double n)
  (* n 2))

;; apply-all-to-5s : [List [Number -> Z]] -> [Listof Z]
;; apply each function in given list to 5 and return list of answers
;; TRY RUNNING THIS VERSION; YOU'LL NEED TO USE ISL+LAMBDA TO DO IT!
;;    We'll discuss this in class on Thursday.
#;(define (apply-all-to-5s lox)
  (cond [(empty? lox) empty]
        [else (cons ((first lox) 5)
                    (apply-all-to-5s (rest lox)))]))

;; apply-all-to-5s : [List [Number -> Z]] -> [Listof Z]
;; apply each function in given list to 5 and return list of answers
(define (apply-all-to-5s lox)
  (local ((define (apply-to-5 op)
            (op 5)))
    (my-map apply-to-5 lox)))

(check-expect (apply-all-to-5s empty) empty)
(check-expect (apply-all-to-5s (list add1 sub1 zero? double number->string))
              (list 6 4 false 10 "5"))