1. COSC 4P41 Functional Programming
Instructor: Michael Winter
Office J323
Office Hours: Mon 10:00am – noon, Thu 01:00pm – 03:00pm
Webpage:
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:

2. Textbooks
Main Text
Haskell, The Craft of Functional Programming,  3rd edition, S. Thompson, Addison - Wesley (2011), ISBN
Supplemental Texts
The Haskell 2010 Report, Simon Marlow, online.
Real World Haskell, Bryan O'Sullivan, John Goerzen, Don Steward, O'Reilly (2009), ISBN
The Haskell School of Expression, P. Hudak, Cambridge University Press (2000), ISBN

3. Course Work Marking Scheme Lab Tests (3x20%) 60% Final Lab Exam 40%
Tests & Exam (D205)
Lab Test 1 September 11:00am – 12:30pm
Lab Test 2 October 11:00am – 12:30pm
Lab Test 3 November 11:00am – 12:30pm
Exam December tba

4. 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.

5. Course Outline * Oct 08-12 is Reading Week. Week Date Book/Chapt.
Topics 1
Sep 07/11
[1] 1–3
Introduction to Functional Programming 2
Sep 14/18
[1] 4–5
Recursion and Data Types 3
Sep 21/25
[1] 6–7
Lists 4
Sep 28/Oct 02
[1]  9-10
Patterns of Computation, Functions as Values 5
Oct 05/16*
[1] 12-13
Overloading, Type Classes, Type Checking 6
Oct 19/23
[1] 14-15
Algebraic Types 7
Oct 26/30
[1] 16
Abstract Data Types 8
Nov 02/06
[1] 17
Lazy Evaluation 9
Nov 09/13
[1] 18
Programming with Actions 10
Nov 16/20
[1] 8, 14.7 & 17.9
Reasoning about Programs 11
Nov 23/27
Reasoning about Programs II 12
Nov 30/Dec 04
[2] 7
Language extensions, Review
* Oct is Reading Week.

6. 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

7. 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

8. 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”

9. What is a function?
A function is something which produces an output value depending on the input value(s). + 12 34 46
inputs
output
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
A functional program is basically a list of definitions of functions.

10. 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

11. {-#########################################################
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))

12. ###########################################################
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))

13. The Booleans type Bool operations exOr :: Bool -> Bool -> Bool
exOr x y = (x || y) && not (x && y)
&&
and || or
not

14. The integers type Int: range –2147483648…2147483647
type Integer: range unbounded
operations +
sum *
product ^
raise to the power -
difference
div
whole number division
mod
remainder
abs
absolute value
negate
change sign

15. Relational operators and overloading
(==) 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
>
greater than
>=
greater than or equal to ==
equal to /=
not equal to
<=
less than or equal to
<
less than

16. The rational numbers type Rational (import Ratio) operations
and +, *, -, negate, abs %
Integer -> Integer -> Rational
numerator
the numerator
denominator
the denominator
fromInteger
Integer -> Rational

17. The characters type Char ‘a’ ‘\t’ tab ‘\n’ newline ‘\\’ backslash
‘\’’ single quote
‘\”’ double quote
‘\97’ character with ASCII code 97, i.e., ‘9’

18. Layout mystery x = x*x +x +2 next x = … fun v1 v2 … vn | g1 = e1
| otherwise = er

19. 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