-
Notifications
You must be signed in to change notification settings - Fork 3
/
Chapter_11.hs
134 lines (85 loc) · 2.31 KB
/
Chapter_11.hs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
module Chapter_11
where
import Chapter_06
import Data.List
-- Exercise 11.1
infixl 9 >.>
(>.>) :: (a -> b) -> (b -> c) -> (a -> c)
g >.> f = f . g
-- Using standard composition
produceBill :: TillType -> String
produceBill = formatBill . makeBill
-- Using forward composition >.>
produceBill' :: TillType -> String
produceBill' = makeBill >.> formatBill
-- Exercise 11.2
{-
All these functions are the same - they all resolve to f.
-}
-- Exercise 11.3
{-
If we have functions:
f :: a -> b
g :: b -> c
h :: c -> d
then the general composition h.g.f is
h.g.f :: a -> d
Example:
-}
myToInt :: Char -> Int
myToInt c = case c of
'a' -> 100
'b' -> 200
_ -> 300
vat :: Int -> Double
vat x = 1.23 * (fromInteger (toInteger x))
printDouble :: Double -> [Char]
printDouble d
| d > 200.0 = "More than (>) two hundred"
| otherwise = "Less than (<) two hundred"
{-
composed_function = printDouble . vat . myToInt :: Char -> [Char]
In order for use to have a list of functions, the list must be homogeneous, so at best it
must be of the form:
[(a -> b)]
However, the output of one function feeds into the next, so both a and b must be of
the same type:
[(a -> a)]
-}
-- Using recursion
composeList :: [(a -> a)] -> (a -> a)
composeList [] = id
composeList (f:fs) = f . composeList fs
-- Using a fold
composeList' :: [(a -> a)] -> (a -> a)
composeList' fs = foldr (.) id fs
-- Test functions
addOne :: Int -> Int
addOne a = a + 1
mulTen :: Int -> Int
mulTen a = a * 10
subThree :: Int -> Int
subThree a = a - 3
funcList = [subThree, mulTen, addOne]
-- Exercise 11.4
{-
:t ($)
($) :: (a -> b) -> a -> b
-}
-- Exercise 11.5
result = zipWith ($) [sum, product] [[1, 2], [3, 4]]
{-
This gives the sum of the integers in the first element, and the product of the
integers in the second element:
[($) sum [1, 2], ($) product [3, 4]]
[3, 12]
-}
-- Exercise 11.6
{-
(id $ f) -- This is the same as f
(f $ id) -- Doesn't make sense? But you can say (if f :: Int -> b)
-- f $ id 7
id ($) -- This is the same as $
-}
-- Exercise 11.7
-- Exercise 11.8