COSC 4P41 – Functional Programming
COSC 4P41
Functional Programming
• Instructor: Michael Winter
– Office J323
– Office Hours: Mon & Fri 10:00am – noon
– email: mwinter@brocku.ca
• Webpage:
http://www.cosc.brocku.ca/~mwinter/Courses/4P41/
• Course Description (Brock Calendar):
Introduction to functional programming using the languages Haskell.
Topics include all data types, type inference, pattern-matching, recursion,
polymorphism, higher-order functions, lazy vs eager evaluation,
modules and monads.
• Prerequisites: three and one-half COSC credits or permission of the
instructor.
• Haskell:
http://www.haskell.org
© M. Winter
1.1
COSC 4P41 – Functional Programming
Textbooks
• Main Text
– Haskell, The Craft of Functional Programming, 3rd edition, S.
Thompson, Addison - Wesley (2011), ISBN 0-201-88295-7
• Supplemental Texts
– The Haskell 2010 Report, Simon Marlow, online.
– Real World Haskell, Bryan O'Sullivan, John Goerzen, Don
Steward, O'Reilly (2009), ISBN 978-0-596-51498-3
– The Haskell School of Expression, P. Hudak, Cambridge
University Press (2000), ISBN 0-521-64408-9
© M. Winter
1.2
COSC 4P41 – Functional Programming
Course Work
• Marking Scheme
– Lab Tests (3x20%)
– Final Lab Exam
• Tests & Exam (D205)
Lab Test 1
Lab Test 2
Lab Test 3
Exam
© M. Winter
60%
40%
February 01 @ 2:00pm – 3:30pm
February 29 @ 2:00pm – 3:30pm
March 21 @ 2:00pm – 3:30pm
April 06 @ tba
1.3
COSC 4P41 – Functional Programming
• A mark of at least 40% on the final exam is required to achieve a passing
grade in this course.
• Consideration regarding illness for test dates will only be considered if
accompanied with the completed Departmental Medical Excuse form.
• Academic misconduct is a serious offence. The principle of academic
integrity, particularly of doing one's own work, documenting properly
(including use of quotation marks, appropriate paraphrasing and
referencing/citation), collaborating appropriately, and avoiding
misrepresentation, is a core principle in university study. Students
should consult Section VII, 'Academic Misconduct", in the "Academic
Regulations and University Polices“ entry in the Undergraduate
Calendar, available at brocku.ca/webcal to view a fuller description of
prohibited actions, and the procedures and penalties.
© M. Winter
1.4
COSC 4P41 – Functional Programming
Course Outline
Week
Date
Book/Chapt.
Topics
1
Jan 04/08
[1] 1–3
Introduction to Functional Programming
2
Jan 11/15
[1] 4–5
Recursion and Data Types
3
Jan 18/22
[1] 6–7
Lists
4
Jan 25/29
[1] 9-10
Patterns of Computation, Functions as Values
5
Feb 01/05
[1] 12-13
Overloading, Type Classes, Type Checking
6
Feb 08/12
[1] 14-15
Algebraic Types
7
Feb 22/26*
[1] 16
Abstract Data Types
8
Feb 29/Mar 04 [1] 17
Lazy Evaluation
9
Mar 07/11
[1] 18
Programming with Actions
10
Mar 14/18
[1] 8, 14.7 & 17.9
Reasoning about Programs
11
Mar 21/28**
[1] 8, 14.7 & 17.9
Reasoning about Programs II
12
Apr 01/04
[2] 7
Language extensions, Review
*Feb 17-21 is Reading Week.
**Mar 25 is Good Friday. Make-up on Apr 04.
© M. Winter
1.5
COSC 4P41 – Functional Programming
Imperative languages
• Von Neumann model:
– store with addressable locations
• machine code:
– effect achieved by changing contents of store locations
– instructions executed in sequence, flow of control altered by jumps
• imperative language:
– variable corresponds to store location
– instructions executed in sequence, flow of control altered by
conditional and loop statements
– efficient implementation since close to design of conventional
computers
© M. Winter
1.6
COSC 4P41 – Functional Programming
Functional languages
•
•
•
•
computational model: lambda calculus
mathematical functions: domain, range
functional languages achieve effect by applying functions
functional vs. imperative languages
– store location
– assignment statement vs. application of a function (expressions)
• side-effects
• aliasing
• referential transparency
© M. Winter
1.7
COSC 4P41 – Functional Programming
Features of functional languages
• usually strongly typed (modern languages)
• algebraic type definitions
– mathematical based notation
– no (implicit) pointers
• higher-order functions
– can accept functions as parameters
– can return functions as results
• recursion as a basic principle
• application of rewrite rule:
– function call replaced by code body
• run-time overhead  garbage collection
• slogan: define “what to do”, not “how to do”
© M. Winter
1.8
COSC 4P41 – Functional Programming
What is a function?
A function is something which produces an output value depending on the input value(s).
12
34
inputs
+
output
46
A type is a collection of values. Usually functions are considered to take values of
specific types as input, and produce values of another type.
Int
Int
+
Int
A functional program is basically a list of definitions of functions.
© M. Winter
1.9
COSC 4P41 – Functional Programming
Definitions
Haskell definitions are of the form:
name :: type
name = expression
Examples:
size :: Int
size = (12+13)*4
square :: Int -> Int
square n = n*n
© M. Winter
1.10
COSC 4P41 – Functional Programming
{-#########################################################
FirstScript.hs
Simon Thompson, June 1998
The purpose of this script is
- to illustrate some simple definitions
over integers (Int);
- to give a first example of a script.
#########################################################-}
-- The value size is an integer (Int), defined to be
-- the sum of twelve and thirteen.
size :: Int
size = 12+13
-- The function to square an integer.
square :: Int -> Int
square n = n*n
-- The function to double an integer.
double :: Int -> Int
double n = 2*n
-- An example using double, square and size.
example :: Int
example = double (size - square (2+2))
© M. Winter
1.11
COSC 4P41 – Functional Programming
###########################################################
FirstLiterate.lhs
Simon Thompson, June 1998
The purpose of this script is
- to illustrate some simple definitions
over integers (Int);
- to give a first example of a literate script.
###########################################################
The value size is an integer (Int), defined to be the sum of
twelve and thirteen.
>
>
size :: Int
size = 12+13
The function to square an integer.
>
>
square :: Int -> Int
square n = n*n
The function to double an integer.
>
>
double :: Int -> Int
double n = 2*n
An example using double, square and size.
>
>
example :: Int
example = double (size - square (2+2))
© M. Winter
1.12
COSC 4P41 – Functional Programming
The Booleans
• type Bool
• operations
&&
and
||
or
not
not
exOr :: Bool -> Bool -> Bool
exOr x y = (x || y) && not (x && y)
© M. Winter
1.13
COSC 4P41 – Functional Programming
The integers
• type Int: range –2147483648…2147483647
• type Integer: range unbounded
• operations
+
sum
© M. Winter
*
product
^
raise to the power
-
difference
div
whole number division
mod
remainder
abs
absolute value
negate
change sign
1.14
COSC 4P41 – Functional Programming
Relational operators and overloading
>
greater than
>= greater than or equal to
== equal to
/= not equal to
<= less than or equal to
<
less than
(==) for integers and Booleans. This means that (==) will have the type
Int -> Int -> Bool
Bool -> Bool -> Bool
Indeed t -> t -> Bool if the type t carries an equality.
(==) :: Eq a => a -> a -> Bool
© M. Winter
1.15
COSC 4P41 – Functional Programming
The rational numbers
• type Rational (import Ratio)
• operations
%
Integer -> Integer -> Rational
numerator
the numerator
denominator
the denominator
fromInteger
Integer -> Rational
and +, *, -, negate, abs
© M. Winter
1.16
COSC 4P41 – Functional Programming
The characters
• type Char
‘a’
‘\t’
‘\n’
‘\\’
‘\’’
‘\”’
‘\97’
© M. Winter
tab
newline
backslash
single quote
double quote
character with ASCII code 97, i.e., ‘9’
1.17
COSC 4P41 – Functional Programming
Layout
mystery x = x*x
+x
+2
next x = …
fun v1 v2 … vn
| g1
= e1
| g2
= e2
…
| otherwise = er
© M. Winter
1.18
COSC 4P41 – Functional Programming
Operators and Do-it-yourself operators
(+) :: Int -> Int -> Int
(+) 2 3 = 2 + 3
2 `max` 3 = max 2 3
Operator symbols !,#,$,%,&,*,+,.,/,<,=,>,?,\,^,|,:,-,~
(&&&) :: Int -> Int -> Int
x &&& y
| x > y
= y
| otherwise = x
© M. Winter
1.19