;; length: list --> number
;; Return the length of data.
;;
(define (my-length data)
  (cond [(empty? data) 0]
        [(cons?  data) (add1 (my-length (rest data)))]))

;; sum: list-of-number --> number
;; Return the sum of all numbers in data.
;;
(define (sum data)
  (cond [(empty? data) 0]
        [(cons?  data) (+ (first data) (sum (rest data)))]))


(my-length empty)
0
(my-length (cons 4 empty))
1
(my-length (cons 7 (cons 129 (cons 4 empty))))
3

(sum empty)
0
(sum (cons 4 empty))
4
(sum (cons 7 (cons 129 (cons 4 empty))))
140




;; Examples of datalists:     <a name="datalist-examples"></a>
(define pengs0 empty)
(define pengs1 (cons 23 (cons 47 empty))) ; No fog days.
(define pengs2 (cons 'fog empty))
(define pengs3 (cons 'fog (cons 'fog (cons 'fog (cons 'fog empty)))))
(define pengs4 (cons 23 (cons 'fog (cons 462 (cons 23 empty)))))
(define pengs5 (cons 'fog (cons 500 (cons 300 (cons 'fog empty)))))


(define critical-penguin-mass 400)
                  
;; parties: datalist --> list-of-boolean   <a name="parties"></a>
;; For each proper penguin-count in data,
;; replace it with true/false depending on whether
;; it was at least critical-penguin-mass.
;; 'fog entries contribute nothing to the output.
;;
(define (parties data)
  (cond 
    [(empty? data) empty]
    [(and (cons? data) (symbol? (first data)))
     (parties (rest data))]
    [(and (cons? data) (number? (first data)))
     (cons (>= (first data) critical-penguin-mass)
           (parties (rest data)))]))

"Testing parties."

(parties pengs0)
empty

(parties pengs1)
(cons false (cons false empty))

(parties pengs2)
empty

(parties pengs3)
empty

(parties pengs4)
(cons false (cons true (cons false empty)))

(parties pengs5)
(cons true (cons true empty))


;;;;;;;;;;;;;;;;;;;;;; fudging the data    <a name="fudge"></a>

;; fudge: datalist --> datalist
;; "massage" data, as described.
;;
(define initial-cooked-datum 345)
(define (fudge data) (fudge-help data initial-cooked-datum))

;; fudge-help: datalist --> datalist
;; ppc is the Previous-Penguin-Count,
;; a value accumulated from previously-processed parts
;; of the list.
;;
;; If the next entry is a fog day, replace it with ppc.
;; If the next entry is a valid datum, leave it alone,
;;   though we'll take that as our new updated ppc.
;;
(define (fudge-help data ppc)
  (cond 
    [(empty? data) empty]
    [(and (cons? data) (symbol? (first data)))
     (cons ppc (fudge-help (rest data) ppc))]
    [(and (cons? data) (number? (first data)))
     (cons (first data) (fudge-help (rest data) (first data)))]))


"Test fudge."

(fudge pengs0)
empty
(fudge pengs1)
(cons 23 (cons 47 empty))

(fudge pengs2)
(cons initial-cooked-datum empty)

(fudge pengs3)
(cons initial-cooked-datum (cons initial-cooked-datum (cons initial-cooked-datum (cons initial-cooked-datum empty))))

(fudge pengs4)
(cons 23 (cons 23 (cons 462 (cons 23 empty))))

(fudge pengs5)
(cons initial-cooked-datum (cons 500 (cons 300 (cons 300 empty))))


;;;;;;;;;;;;;;;;;;;;;; increasing?   <a name="increasing?"></a>

;; increasing? datalist --> boolen
;; Are the penguin sightings in data non-decreasing?
;; (Ignoring any 'fog entries.)
;;
(define (increasing? data) (increasing-help? data 0))

;; increasing-help? datalist number --> boolean
;; Are the penguin sightings in data non-decreasing,
;; and the first penguin-sighting >= ppc?
;; (Ignoring any 'fog entries.)
;; (If no penguin sightings, or only one,
;; this will be vacuously true.)
;;
;; Note: when first called, ppc is zero,
;; since no penguins yet seen.
;; 
(define (increasing-help? data ppc)
  (cond 
    [(empty? data) true]
    [(and (cons? data) (symbol? (first data)))
     (increasing-help? (rest data) ppc)]
    [(and (cons? data) (number? (first data)))
     (and (>= (first data) ppc)
          (increasing-help? (rest data) (first data)))]))


"Test increasing?."

(increasing? pengs0)
true

(increasing? pengs1)
true

(increasing? pengs2)
true

(increasing? pengs3)
true

(increasing? pengs4)
false

(increasing? pengs5)
false

(increasing? (cons 'fog (cons 23 (cons 30 (cons 'fog (cons 'fog (cons 452 (cons 453 (cons 'fog empty)))))))))
true