-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathWeek2_Notes.html
More file actions
234 lines (184 loc) · 14.7 KB
/
Week2_Notes.html
File metadata and controls
234 lines (184 loc) · 14.7 KB
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
<!DOCTYPE html><html><head><meta charset="utf-8">
<link rel="stylesheet" type="text/css" href="styles.css">
<title>Week2_Notes</title></head><body><article class="markdown-body"><h1>
<a id="week2-notes-of-haskell-building-blocks----functional-programming-in-haskell-mooc" class="anchor" href="#week2-notes-of-haskell-building-blocks----functional-programming-in-haskell-mooc" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Week2 Notes of "Haskell Building Blocks" -- "Functional Programming in Haskell" MOOC</h1>
<h2>
<a id="contents" class="anchor" href="#contents" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Contents</h2>
<ul>
<li>
<a href="#boolean-values-and-expressions">Boolean Values and Expressions</a>
<ul>
<li><a href="#equality-and-comparison-operators">Equality and Comparison Operators</a></li>
<li><a href="#testing-list-membership-with-the-elem-function">Testing List membership with the <code>elem</code> function</a></li>
<li><a href="#using-infix-and-prefix-operations">Using infix and prefix operations</a></li>
</ul>
</li>
<li><a href="#more-boolean-operations">More Boolean Operations</a></li>
<li><a href="#zipping-lists">Zipping Lists</a></li>
<li><a href="#input--output">Input / Output</a></li>
<li><a href="#io-monad">I/O Monad</a></li>
<li><a href="#installing-haskell">Installing Haskell</a></li>
</ul>
<hr>
<h2>
<a id="boolean-values-and-expressions" class="anchor" href="#boolean-values-and-expressions" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Boolean Values and Expressions</h2>
<h3>
<a id="equality-and-comparison-operators" class="anchor" href="#equality-and-comparison-operators" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Equality and Comparison Operators</h3>
<ul>
<li>Boolean Values are either <code>True</code> and <code>False</code>.</li>
<li>Double-equals operator <code>==</code> is used for testing value equality.</li>
<li>Not-equals operator is <code>/=</code> (looks like an equals sign with a line through it).</li>
<li>Haskell cannot compare two values that have different types.</li>
<li>Haskell supports the standard comparison / relational operators, <code><</code>, <code><=</code>, <code>></code>, <code>>=</code>.</li>
</ul>
<h3>
<a id="testing-list-membership-with-the-elem-function" class="anchor" href="#testing-list-membership-with-the-elem-function" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Testing List membership with the <code>elem</code> function</h3>
<ul>
<li>
<code>elem</code> function returns true if a value is part of a list, and false otherwise.</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-c1">elem</span> <span class="pl-c1">1</span> [<span class="pl-c1">1</span>,<span class="pl-c1">2</span>,<span class="pl-c1">3</span>] <span class="pl-c">-- > True</span></pre></div>
<h3>
<a id="using-infix-and-prefix-operations" class="anchor" href="#using-infix-and-prefix-operations" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Using infix and prefix operations</h3>
<ul>
<li>Haskell permits any two-argument function to be written as an infix operator using backquote (`) characters.</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-c1">1</span> <span class="pl-k">`elem`</span> [<span class="pl-c1">1</span>,<span class="pl-c1">2</span>,<span class="pl-c1">3</span>] <span class="pl-c">-- > True</span>
<span class="pl-c1">42</span> <span class="pl-k">`max`</span> <span class="pl-c1">13</span> <span class="pl-c">-- > 42</span>
(+) <span class="pl-c1">1</span> <span class="pl-c1">1</span> <span class="pl-c">-- > 2</span></pre></div>
<hr>
<h2>
<a id="more-boolean-operations" class="anchor" href="#more-boolean-operations" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>More Boolean Operations</h2>
<ul>
<li>The <code>not</code> function returns the opposite boolean value, the logical complement.</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-c1">not</span> <span class="pl-ent"><span class="pl-c1">True</span></span> <span class="pl-c">-- > False</span>
<span class="pl-c1">not</span> (<span class="pl-c1">not</span> <span class="pl-ent"><span class="pl-c1">False</span></span>) <span class="pl-c">-- > False</span></pre></div>
<ul>
<li>
<code>&&</code> infix operator is a boolean conjunction (<code>AND</code> function).</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-ent"><span class="pl-c1">True</span></span> && <span class="pl-ent"><span class="pl-c1">True</span></span> <span class="pl-c">-- > True</span>
<span class="pl-ent"><span class="pl-c1">False</span></span> && <span class="pl-ent"><span class="pl-c1">True</span></span> <span class="pl-c">-- > False</span></pre></div>
<ul>
<li>
<code>||</code> infix operator is a boolean disjunction (logical <code>OR</code>); dual of the <code>AND</code> operation.</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-ent"><span class="pl-c1">True</span></span> || <span class="pl-ent"><span class="pl-c1">False</span></span> <span class="pl-c">-- > True</span>
<span class="pl-ent"><span class="pl-c1">False</span></span> || <span class="pl-ent"><span class="pl-c1">False</span></span> <span class="pl-c">-- > False</span></pre></div>
<ul>
<li>
<code>xor</code> function returns true when its two boolean arguments are different.</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-ent"><span class="pl-c1">True</span></span> <span class="pl-k">`xor`</span> <span class="pl-ent"><span class="pl-c1">False</span></span> <span class="pl-c">-- > True</span>
<span class="pl-ent"><span class="pl-c1">False</span></span> <span class="pl-k">`xor`</span> <span class="pl-ent"><span class="pl-c1">False</span></span> <span class="pl-c">-- > False</span></pre></div>
<ul>
<li>Haskell supports multi-input boolean operations with <code>and</code> and <code>or</code> functions that take a list of boolean values as a single input.</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-c1">and</span> [<span class="pl-ent"><span class="pl-c1">False</span></span>, <span class="pl-ent"><span class="pl-c1">True</span></span>, <span class="pl-ent"><span class="pl-c1">False</span></span>, <span class="pl-ent"><span class="pl-c1">True</span></span>] <span class="pl-c">-- > False</span>
<span class="pl-c1">or</span> [<span class="pl-ent"><span class="pl-c1">True</span></span>, <span class="pl-ent"><span class="pl-c1">True</span></span>, <span class="pl-ent"><span class="pl-c1">False</span></span>] <span class="pl-c">-- > True</span></pre></div>
<ul>
<li>
<code>if</code> expressions evaluate to either the <code>then</code> value or the <code>else</code> value, based on the <code>if</code> value.</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-k">if</span> <span class="pl-c1">2</span>*<span class="pl-c1">2</span>==<span class="pl-c1">4</span> <span class="pl-k">then</span> <span class="pl-s"><span class="pl-pds">"</span>happy<span class="pl-pds">"</span></span> <span class="pl-k">else</span> <span class="pl-s"><span class="pl-pds">"</span>sad<span class="pl-pds">"</span></span> <span class="pl-c">-- > "happy"</span>
<span class="pl-k">if</span> <span class="pl-ent"><span class="pl-c1">True</span></span> <span class="pl-k">then</span> <span class="pl-c1">42</span> <span class="pl-k">else</span> <span class="pl-c1">pi</span> <span class="pl-c">-- > 42.0</span></pre></div>
<hr>
<h2>
<a id="zipping-lists" class="anchor" href="#zipping-lists" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Zipping Lists</h2>
<ul>
<li>
<code>zip</code> function combines a pair of lists into a list of pairs.
<ul>
<li>If <code>zip</code> function is used on lists which are of different lengths, length of the output list will be the length of the shortest list.</li>
</ul>
</li>
<li>
<code>zip3</code> function combines three lists into a triplet.</li>
<li>By adding <code>import Data.List</code>, we get pre-baked definitions of <code>zip3</code> ... <code>zip7</code> and <code>zipWith3</code> ... <code>zipWith7</code>.</li>
<li>
<code>zipWith</code> function is a generalization of <code>zip</code>.
<ul>
<li>While <code>zip</code> can only combine elements from two input lists by creating pairs of those elements, <code>zipWith</code> allows us to provide a function that tells us how to combine the elements from the input lists.</li>
<li>
<code>zipWith</code> function applies a function to the result of <code>zip</code>.</li>
<li>
<code>zipWith</code> function can take a lambda function for the operation.</li>
</ul>
</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-c1">zip</span> [<span class="pl-c1">1</span>,<span class="pl-c1">2</span>,<span class="pl-c1">3</span>] [<span class="pl-c1">4</span>,<span class="pl-c1">5</span>] <span class="pl-c">-- > [(1,4),(2,5)]</span>
<span class="pl-c1">zipWith</span> <span class="pl-c1">max</span> [<span class="pl-c1">1</span>,<span class="pl-c1">2</span>,<span class="pl-c1">3</span>] [<span class="pl-c1">0</span>,<span class="pl-c1">2</span>,<span class="pl-c1">4</span>] <span class="pl-c">-- > [1,2,4]</span>
<span class="pl-c1">zipWith</span> (+) [<span class="pl-c1">1</span>,<span class="pl-c1">2</span>,<span class="pl-c1">3</span>] [<span class="pl-c1">0</span>,<span class="pl-c1">2</span>,<span class="pl-c1">4</span>] <span class="pl-c">-- > [1,4,7]</span>
<span class="pl-c1">zipWith</span> (\x->(\y->(x,y))) [<span class="pl-c1">1</span>,<span class="pl-c1">2</span>,<span class="pl-c1">3</span>] <span class="pl-s"><span class="pl-pds">"</span>abc<span class="pl-pds">"</span></span> <span class="pl-c">-- > [(1,'a'),(2,'b'),(3,'c')] -- Note: Strings in Haskell are list of characters</span></pre></div>
<hr>
<h2>
<a id="input--output" class="anchor" href="#input--output" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Input / Output</h2>
<ul>
<li>Input is with <code>getLine</code> and output is with <code>putStrLn</code>.</li>
<li>
<code>putStrLn</code> (like <code>println</code> in Java or <code>print</code> in Python) prints a character string to the terminal.</li>
<li>
<code>getLine</code> function reads in a character string from user input.
<ul>
<li>After <code>getLine</code> function is invoked, text should be typed at the <code>></code> prompt followed by pressing the enter key.</li>
</ul>
</li>
<li>
<code>read</code> reads values as strings, and converts them into other types.
<ul>
<li>A type annotation (for example: <code>::Int</code>) is mandatory; otherwise it is not clear what type of number the input String is meant to represent.</li>
</ul>
</li>
<li>
<code>show</code> takes a value and returns a String representation of that value.
<ul>
<li>
<code>show</code> function is the dual of the <code>read</code> function.</li>
</ul>
</li>
<li>
<code>read</code> and <code>show</code> functions synthesize values from Strings and vice versa.</li>
<li>
<code>print</code> does the composition of <code>putStrLn</code> and <code>show</code>.</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-c1">putStrLn</span> (<span class="pl-s"><span class="pl-pds">"</span>hello <span class="pl-pds">"</span></span> ++ <span class="pl-s"><span class="pl-pds">"</span>world<span class="pl-pds">"</span></span> ++ <span class="pl-s"><span class="pl-pds">"</span>!!<span class="pl-pds">"</span></span>) <span class="pl-c">-- > "hello world!!" -- :: String</span>
<span class="pl-k">do</span> {
<span class="pl-c1">putStrLn</span> <span class="pl-s"><span class="pl-pds">"</span>what is your name?<span class="pl-pds">"</span></span>
x <- <span class="pl-c1">getLine</span>
<span class="pl-c1">putStrLn</span> (<span class="pl-s"><span class="pl-pds">"</span>hello <span class="pl-pds">"</span></span> ++ x)
}
<span class="pl-c1">read</span> <span class="pl-s"><span class="pl-pds">"</span>42<span class="pl-pds">"</span></span> <span class="pl-k">::</span> <span class="pl-en"><span class="pl-c1">Int</span></span> <span class="pl-c">-- > 42 -- :: Int</span>
<span class="pl-c1">show</span> <span class="pl-c1">42</span> <span class="pl-c">-- > "42" -- :: String</span>
<span class="pl-c1">print</span> <span class="pl-c1">42</span> <span class="pl-c">-- > 42 -- :: IO ()</span></pre></div>
<hr>
<h2>
<a id="io-monad" class="anchor" href="#io-monad" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>I/O Monad</h2>
<ul>
<li>Input and output (I/O) operations are impure.</li>
<li>Use <code>do</code> to specify a sequence of actions.</li>
<li>Use <code><-</code> inside a do to associate input values with names.</li>
<li>Any value or function that involves I/O has IO in its type.</li>
<li>Note: <code><-</code> is for associating names with values in do blocks;
<ul>
<li>Whereas <code>-></code> is used for defining functions.</li>
</ul>
</li>
</ul>
<div class="highlight highlight-source-haskell"><pre><span class="pl-k">let</span> greet<span class="pl-c1">()</span> = <span class="pl-k">do</span>
planet <- <span class="pl-c1">getLine</span>
home <- <span class="pl-c1">getLine</span>
<span class="pl-c1">putStrLn</span> (<span class="pl-s"><span class="pl-pds">"</span>greetings <span class="pl-pds">"</span></span> ++ planet ++ <span class="pl-s"><span class="pl-pds">"</span>ling.<span class="pl-pds">"</span></span>)
<span class="pl-c1">putStrLn</span> (<span class="pl-s"><span class="pl-pds">"</span>I am from <span class="pl-pds">"</span></span> ++ home ++ <span class="pl-s"><span class="pl-pds">"</span>.<span class="pl-pds">"</span></span>)
<span class="pl-c1">putStrLn</span> <span class="pl-s"><span class="pl-pds">"</span>Take me to your leader.<span class="pl-pds">"</span></span></pre></div>
<hr>
<h2>
<a id="installing-haskell" class="anchor" href="#installing-haskell" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Installing Haskell</h2>
<p>Two bundled distributions of GHC are:</p>
<ul>
<li>
<a href="https://www.haskell.org/platform">Haskell Platform</a> and</li>
<li><a href="https://docs.haskellstack.org/en/stable/README/">Stack</a></li>
</ul>
<hr>
</article></body></html>