;; The first three lines of this file were inserted by DrRacket. They record metadata
;; about the language level of this file in a form that our tools can easily process.
#reader(lib "htdp-beginner-reader.ss" "lang")((modname list-intro-before) (read-case-sensitive #t) (teachpacks ()) (htdp-settings #(#t constructor repeating-decimal #f #t none #f () #f)))
(require "let-for-bsl.rkt")


#| Follow the design recipe (the final version!):
  ---- Per data type:
     1. Choose data definition
     2. Give some examples of the data
     3. Template:
        a. If handling a union type, include a cond w/ one branch per option.
        b. If handling a product-type, pull out each piece (field).
        c. Add the natural recursive call (as appropriate)
        d. Inventory: In all cases, think about what *type* (each piece) is,
           and think of some functions that process that type.

  ---- Per function:
     4. write test cases
     5. (a-d): header, purpose, contract/type, copy the template, and stub it.
     6. Inventory with values: Consider a particular test case,
        and think about what *specific* *value* of each sub-expression.
     7. complete the body
     8. run tests

|#


#| Definition:
   argument:  the value passed into a function
   parameter: a function's local variable/identifier which is
              initialized from the arguments (each time the function is *called*).
|#




#|  Today's+Tomorrow's outline:
1. Design recipe (recall, v.quickly).


2. data def'n for: list
   (including the non-built-in-way)


3. processing a list:
    sum
    write: length
    write: contains?   (return a bool)
    write: triple-every-even   (return a *list*)
    write: my-max  (note bad run-time)
    learn: let*

|#


; Data Definition:
; list-of-number is:
;      '(), OR
;      (make-cons [number] [list-of-number])   ; "constructed list"




; Examples of data:



; '() is the empty list; there is also the named-constant `empty`.
; cons is a built-in structure with two fields: first, rest
;(define-struct cons (first rest))

; The constructor isn't *actually* `make-cons`,  but instead just `cons`.
; The selectors  aren't *actually* `cons-first`, but instead just `first`
;                        and not   `cons-rest`,  but instead just `rest`.
;
; There *is* a predicate `cons? : ANY -> boolean`.
; Also, there is a predicate to test for the empty-list:  `empty? : ANY -> boolean`


;; template:
; func-for-list : list-of-num -> ???
;
(define (func-for-list a-lon)
   ...)

; sum : list-of-num -> num
(check-expect (sum '()) 0)
(check-expect (sum (cons 3 '())) 3)
(check-expect (sum (cons 4 (cons 3 '()))) 7)
(check-expect (sum (cons 5 (cons 4 (cons 3 '())))) 12)





              

; sum : list-of-number -> number
; Return the sum of all the numbers in `a-lon`.
;
(define (sum a-lon)
   ...)


  ; inventory with values: suppose that `a-lon` stands for
  ; (cons 5 (cons 4 (cons 3 '()))).
  ;  So what is (first a-lon) in this case?  5      <---
  ;  So what is (rest a-lon) in this case?
  ;                        (cons 4 (cons 3 '()))   <---
  ;  So what is (sum (rest a-lon)) in this case?  7   <---
  ;   sub-question: what is (rest a-lon) in this case?  (cons 2 (cons 4 '()))
  ;  So what should my answer be in this case?    12

(check-expect (sum '()) 0)

(check-expect (sum (cons 4 '()))  4)
(check-expect (sum (cons 2 (cons 4 '())))   6)
(check-expect (sum (cons 3 (cons 2 (cons 4 '()))))  9)


(check-expect (my-length '()) 0)
(check-expect (my-length (cons 4 '())) 1)
(check-expect (my-length (cons 2 (cons 4 '()))) 2)
(check-expect (my-length (cons 99 (cons 2 (cons 4 '())))) 3)


; my-length : list-of-number -> natnum
; Return the length of `a-lon`.
;
(define (my-length a-lon)
   ...)



; contains-93? : list-of-number -> boolean
; Return whether `a-lon` contains 93.
;
(define (contains-93? a-lon)
  #false)









(check-expect (contains-93? '()) #f)
(check-expect (contains-93? (cons 93 '())) #t)
(check-expect (contains-93? (cons  7 '())) #f)
(check-expect (contains-93? (cons  7 (cons 93 '()))) #t)
(check-expect (contains-93? (cons 93 (cons  7 '()))) #t)
(check-expect (contains-93? (cons  3 (cons  7 '()))) #f)

(check-expect (contains-93? (cons 44 (cons 93 (cons  7 '())))) #t)
(check-expect (contains-93? (cons 44 (cons  3 (cons  7 '())))) #f)



#| truth-table:
 inputA inputB  desired-answer
    #f    #f  |  #f
    #f    #t  |  #t
    #t    #f  |  #t
    #t    #t  |  #t
|#







; contains? : list-of-number, number -> boolean
; Does `alon` contain `target`?
;
#;(define (contains? a-lon target)
   #false)
; Alternately: we can simplify `(if <cond> true <boolexpr>)`
;                           to `(or <cond> <boolexpr>)`






(check-expect (contains? '() 4) false)

(check-expect (contains? (cons 4 '()) 4) true)
(check-expect (contains? (cons 4 '()) 99) false)

(check-expect (contains? (cons 2 (cons 4 '())) 99) false)
(check-expect (contains? (cons 2 (cons 4 '())) 2) true)
(check-expect (contains? (cons 2 (cons 4 '())) 4) true)

(check-expect (contains? (cons 93 (cons 2 (cons 4 '()))) 93)
              true)
(check-expect (contains? (cons 93 (cons 2 (cons 4 '()))) 4)
              true)
(check-expect (contains? (cons 93 (cons 2 (cons 4 '()))) 77)
              false)
(check-expect (contains? (cons 93 (cons 2 (cons 93 '()))) 93)
              true)

; contains? : list-of-number, number -> boolean
; Does `alon` contain `target`?
;
(define (contains? a-lon target)
   #false)



;  Functions *returning* a list:


; triple-every-even (and leave odd numbers untouched)
; 
(check-expect (tee '()) ...)
(check-expect (tee (cons 4 '()))
              (cons 12 '()))
(check-expect (tee (cons 7 '()))
              (cons 7 '()))
(check-expect (tee (cons 2 (cons 4 '())))
              (cons 6 (cons 12 '())))
(check-expect (tee (cons 93 (cons 2 (cons 4 '()))))
              (cons 93 (cons 6 (cons 12 '()))))


; tee : list-of-number -> list-of-number
; "triple-every-even" -- return another list like `a-lon`,
; but every even number is tripled (and odd numbers are unchanged).
;
(define (tee a-lon)
  '())