;; any? : [X -> Boolean] [Listof X] -> Boolean
(define (any? test lox)
  (cond [(empty? lox) false]
        [(cons? lox) (or (test (first lox))
                         (any? test (rest lox)))])) 

;; any-evens? : [Listof Number] -> Boolean
;; Are there any even numbers in lon?
(define (any-evens? lon)
  (any? even? lon))
  
(check-expect (any-evens? (list 1 3 5 7)) false)
(check-expect (any-evens? (list 1 3 4 7)) true)
(check-expect (any-evens? (list 2 4)) true)

;; any-positives? : [Listof Number] -> Boolean
;; Are there any positive numbers in lon?
(define (any-positives? lon)
  (any? positive? lon))
  
(check-expect (any-positives? '(-1 0 -2 -1)) false)
(check-expect (any-positives? '(-1 1 0)) true)
(check-expect (any-positives? '(10 4)) true)





;;----------------------------------------------------
;; self-collide? : Posn [Listof Posn] -> Boolean
;; Is head in the same position as any of the segments in the body?
(define (self-collide? head body)
  (local (;; head=? : Posn -> Boolean
          ;; Is p equal to the head?
          (define (head=? p)
            (and (= (posn-x head) (posn-x p)) 
                 (= (posn-y head) (posn-y p))))) 
    (ormap head=? body)))
 
(check-expect (self-collide? (make-posn 4 4) '()) false)

(check-expect (self-collide? (make-posn 4 4)
                             (list (make-posn 1 2)
                                   (make-posn 2 2)
                                   (make-posn 2 3)))
              false)

(check-expect (self-collide? (make-posn 4 4)
                             (list (make-posn 4 3)
                                   (make-posn 4 4)
                                   (make-posn 4 5)))
              true)




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

;; all-evens? : [Listof Number] -> Boolean
;; Are all the numbers in lon even?
(define (all-evens? lon)
  (all? even? lon))

(check-expect (all-evens? (list 1 2 4)) false)
(check-expect (all-evens? (list 2 4 6 8)) true)

;; all-positives? : [Listof Number] -> Boolean
;; Are all the numbers in lon positive?
(define (all-positives? lon)
  (all? positive? lon))
   
(check-expect (all-positives? '(2 0 4)) false)
(check-expect (all-positives? '(20 30 1)) true)


;; all? : [X -> Boolean] [Listof X] -> Boolean
(define (all? test lox)
  (cond [(empty? lox) true]
        [(cons? lox) (and (test (first lox))
                          (all? test (rest lox)))])) 

;; all-gt10?
;; Are all the numbers in lon greater than 10?
(define (all-gt10? lon)
  (local ((define (gt10? n) 
            (> n 10)))
    (andmap gt10? lon)))

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

;; select-evens : [Listof Number] -> [Listof Number]
;; select all the even numbers in the list
(define (select-evens lon)
  (my-filter even? lon))

(check-expect (select-evens '(1 2 3 4)) '(2 4))

(define (my-filter test lox)
  (cond [(empty? lox) empty]
        [(cons? lox) 
         (cond [(test (first lox)) 
                (cons (first lox) 
                      (my-filter test (rest lox)))]
               [else (my-filter test (rest lox))])]))




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

;; my-length : [Listof X] -> Number
;; compute the length of the given list
(define (my-length xs)
  (local ((define (add1-len elt len)
            (add1 len)))
    (foldr add1-len 0 xs)))
  

;; add1 : Number -> Number

;; foldr : [X Y -> Y] Y [Listof X] -> Y
(define (my-foldr op base lox)
  (cond [(empty? lox) base]
        [(cons? lox) (op (first lox)
                         (my-foldr op base (rest lox)))]))

(check-expect (my-length '()) 0)
(check-expect (my-length '(a (b c) d)) 3)
(check-expect (my-length '(1 5 2 2)) 4)






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

;; A NELON is one of: 
;; - (cons Number empty)
;; - (cons Number NELON)

(define (biggest.slow nelon)
  (cond [(empty? (rest nelon)) (first nelon)]
        [else 
         (cond [(< (first nelon) (biggest.slow (rest nelon))) 
                (biggest.slow (rest nelon))]
               [else (first nelon)])]))

;; this will take a very very long time...
; (biggest.slow '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23))

;; biggest : NELON -> Number
;; return the biggest number in the list
(define (biggest nelon)
  (cond [(empty? (rest nelon)) (first nelon)]
        [else 
         (local ((define b (biggest (rest nelon))))
           (cond [(< (first nelon) b) b]
                 [else (first nelon)]))]))

;; Much faster now: 
(biggest '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23))