0. #lang racket #| CSC324 Fall 2020: Exercise 2 |#
1. #|
2.  
3. |#
4. ;-------------------------------------------------------------------------------
5. ; This expression exports functions so they can be imported into other files.
6. ; Don't change it!
7. (provide apply-fns make-counter apply-fns sum-map-both sum-map-both-helper calculate)
8.  
9. (module+ test
10.   ; Import the testing library
11.   (require rackunit))
12.  
13. ;-------------------------------------------------------------------------------
14. ; * Task 1: num-pred *
15. ;-------------------------------------------------------------------------------
16.  
17. #|
18. (num-pred pred lst)
19.   pred: A function that takes one argument and returns a boolean
20.   lst: A list of items.
21.  
22.   Returns the number of items in the lst for which (pred item) returns True
23. |#
24. (define (num-pred pred lst)
25.   (length (filter pred lst)))
26.  
27.  
28. ;-------------------------------------------------------------------------------
29. ; * Task 2: More Higher-Order Functions *
30. ;-------------------------------------------------------------------------------
31.  
32. #|(define (make-counter-helper pred acc)
33.   (if (null? list)
34.       0
35.       (if (pred
36. |#
37.  
38. #|
39. (make-counter pred)
40.   pred: A function that takes one argument and returns a boolean
41.  
42.   Returns a function that takes a list and returns the number of elements
43.   in the list satisfying that predicate.
44. |#
45.  
46. (define (make-counter pred)
47.   (lambda (lst) (length (filter pred lst))))
48.  
49.  
50. ; Uncomment and define these using `make-counter`.
51. (define num-evens-1 (make-counter even?))
52. (define num-many-evens-1 (lambda (lists)
53.                            (cond
54.                              [(null? lists) 0]
55.                              [else
56.                               (let ([first-list (num-evens-1 (first lists))]
57.                                     [rest-list (num-many-evens-1 (rest lists))])
58.                                 (if (< first-list 3)
59.                                     rest-list
60.                                     (+ rest-list 1)))])))
61.  
62. (module+ test
63.   ; TODO: write your own tests to make sure make-counter is implemented correctly.
64.   (test-equal? "num-evens-1: empty list"
65.                (num-evens-1 null)
66.                0)
67.   (test-equal? "num-evens: simple non-empty list"
68.                (num-evens-1 (list 1 2 4))
69.                2)
70.   (test-equal? "num-many-evens-1: empty list"
71.                (num-many-evens-1 null)
72.                0)
73.   (test-equal? "num-many-evens-1: simple non-empty list"
74.                (num-many-evens-1 (list (list 2 4 5 7 8)))
75.                1)
76.  
77. )
78.  
79.  
80. #|
81. (apply-fns fns arg)
82.   fns: A list of unary functions.
83.   arg: A value.
84.  
85.   Returns a list of the results of applying each function in `fns` to `arg`.
86. |#
87. (define (apply-fns fns arg)
88.   ; TODO: replace the (void) with a proper function body.
89.   (if (null? fns)
90.       '()
91.       (cons ((first fns) arg) (apply-fns (rest fns) arg))))
92.  
93. (module+ test
94.   (test-equal? "(apply-fns (list integer? null?) 4)"  ; Test label
95.                (apply-fns (list integer? null?) 4)   ; Actual value
96.                (list #t #f))                         ; Expected value
97.   ; TODO: write more tests
98.   (test-equal? "(apply-fns (list number? null? zero? positive? negative? 5)"
99.                (apply-fns (list number? null? zero? positive? negative?) 5)
100.                (list #t #f #f #t #f))
101. )
102.  
103. #|
104. (sum-map-both fn lst1 lst2)
105.   fn: A function that takes two arguments and returns a number.
106.   lst1: A list
107.   lst2: Another list of equal length
108.  
109.   Precondition: (equal? (length lst1) (length lst2))
110.   You do not need to check the pre-condition. We will only be testing
111.   with tests that satisfy the pre-condition.
112.  
113.   Returns the sum of the `fn` applied to each of the pairs of values
114.   in lst1 and lst2. We would like this function to be *tail-recursive*,
115.   so it should call the helper function `sum-map-both-helper` with
116.   an appropriate initial accumulator value.
117. |#
118. (define (sum-map-both fn lst1 lst2)
119.   (sum-map-both-helper fn lst1 lst2 0))
120.   ; (sum-map-both-helper fn lst1 lst2 TODO))
121.  
122.  
123. #|
124. (sum-map-both-helper fn lst1 lst2 acc)
125.   fn: A function that takes
126.   lst1: A list
127.   lst2: Another list of equal length
128.   acc: A number describing the accumulated values so far
129.  
130.   Precondition: (equal? (length lst1) (length lst2))
131.   You do not need to check the pre-condition. We will only be testing
132.   with tests that satisfy the pre-condition.
133.  
134.   Helper function for sum-map-both-helper. We *will* be testing this
135.   helper function.
136. |#
137. (define (sum-map-both-helper fn lst1 lst2 acc)
138.   (if (null? lst1)
139.       0
140.       (sum-map-both-helper fn (rest lst1) (rest lst2) (+ (fn (first lst1) (first lst2)) acc))))
141.  
142. (module+ test
143.   (test-equal? "(sum-map-both - '(5 10 7) '(2 6 5))" ; Test label
144.                (sum-map-both - '(5 10 7) '(2 6 5))   ; Actual value
145.                9)  ; Expected value = (5 - 2) + (10 - 6) + (7 - 5)
146.   ; TODO: write more tests
147. )
148.  
149. ;-------------------------------------------------------------------------------
150. ; * Task 4: Calculator *
151. ;-------------------------------------------------------------------------------
152.  
153. #|
154. (calculate expr)
155.   expr: An expression generated by the Binary Arithmetic Expression Grammar
156.         described in the handout.
157.  
158.   Return the numerical value of the expression
159. |#
160. (define/match (calculate expr)
161.   [((list '+ expr1 expr2)) (+ (calculate expr1) (calculate expr2))]
162.   [((list '- expr1 expr2)) (- (calculate expr1) (calculate expr2))]
163.   [((list '* expr1 expr2)) (* (calculate expr1) (calculate expr2))]
164.   [((list '/ expr1 expr2)) (/ (calculate expr1) (calculate expr2))]
165.   [(expr) expr])
166.  
167. (module+ test
168.   (require rackunit)
169.   (test-equal? "calculate: +"
170.                (calculate '(+ 2 3)) ;'(+ 2 3) is the same as (list '+ 2 3)
171.                5)
172.   (test-equal? "calculate: /"
173.                (calculate '(/ (+ 2 6) 2))
174.                4))
175.  

=>