1. © M. Winter COSC 4P41 – Functional Programming 1.11.1 COSC 4P41 Functional Programming Instructor: Michael Winter –Office J323 –Office Hours: Tue & Wed 10:00am - 12:00pm –email: mwinter@brocku.ca Webpage: http://www.cosc.brocku.ca/Offerings/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: None Haskell: http://www.haskell.org course procedures –plagiarism

2. © M. Winter COSC 4P41 – Functional Programming 1.21.2 Textbooks Main Text – Haskell, The Craft of Functional Programming, 2 nd edition, S. Thompson, Addison - Wesley (1999), ISBN 0-201-34275-8 Supplemental Texts – The Hugs 98 User Manual, Mark P Jones, Alastair Reid, online documentation. – 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

3. © M. Winter COSC 4P41 – Functional Programming 1.31.3 Course Work Marking Scheme –Programming Assignments (2x10%,2x20%)60% –Final Exam (oral) 40% Programming Assignments NumberDueLate 1Sep 28 @ 1:00pm Sep 30 @ 1:00pm 2Oct 19 @ 1:00pm Oct 21 @ 1:00pm 3Nov 09 @ 1:00pm Nov 11 @ 1:00pm 4Nov 30 @ 1:00pm Dec 02 @ 1:00pm Registration for final exam: Mid of October (Office hours or after class) Final Exam (oral, 30min each): Monday, December 07, 2009

4. © M. Winter COSC 4P41 – Functional Programming 1.41.4 Assignments will be available online. Submission is electronically. Details see webpage. Assignments will be returned by email. Assignments are due at the times specified above and will be accepted late until the indicated time, subject to a penalty of 25%. After the late period, assignments will not be accepted. A mark of at least 40% on the final exam is required to achieve a passing grade in this course. Assignments will be carefully examined regarding plagiarism. Cases of suspected plagiarism will be dealt with according to the University regulations and Departmental procedures. Consideration regarding illness for assignment submission or test dates will only be considered if accompanied with the completed Departmental Medical Excuse form.

5. © M. Winter COSC 4P41 – Functional Programming 1.51.5 Course Outline WeekDateBook/Chapt.Topics 1Sep 14/16[1] 1–3Introduction to Functional Programming 2Sep 21/23[1] 4–5Recursion and Data Types 3Sep 28/30[1] 6–7Lists 4Oct 05/07[1] 9-10Patterns of Computation, Functions as Values 5Oct 14/19*[1] 12-13Overloading, Type Classes, Type Checking 6Oct 21/26[1] 14-15Algebraic Types 7Oct 28/Nov 02[1] 16Abstract Data Types 8Nov 04/09[1] 17Lazy Evaluation 9Nov 11/16[1] 18Programming with Actions 10Nov 18/23[1] 8, 14.7 & 17.9Reasoning about Programs 11Nov 25/30[1] 8, 14.7 & 17.9Reasoning about Programs II 12Dec 02/03[2] 7Hugs – Language extensions, Review * October 12 is Thanksgiving, no classes. Make up on December 03.

6. © M. Winter COSC 4P41 – Functional Programming 1.61.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. © M. Winter COSC 4P41 – Functional Programming 1.71.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. © M. Winter COSC 4P41 – Functional Programming 1.81.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. © M. Winter COSC 4P41 – Functional Programming 1.91.9 What is a function? + 12 34 46 inputs output A functional program is basically a list of definitions of functions. + Int A function is something which produces an output value depending on the input value(s). 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.

10. © M. Winter COSC 4P41 – Functional Programming 1. 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. © M. Winter COSC 4P41 – Functional Programming 1. 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. © M. Winter COSC 4P41 – Functional Programming 1. 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. © M. Winter COSC 4P41 – Functional Programming 1. 13 The Booleans type Bool operations exOr :: Bool -> Bool -> Bool exOr x y = (x || y) && not (x && y) && and || or not

14. © M. Winter COSC 4P41 – Functional Programming 1. 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. © M. Winter COSC 4P41 – Functional Programming 1. 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. © M. Winter COSC 4P41 – Functional Programming 1. 16 The rational numbers type Rational (import Ratio) operations and +, *, -, negate, abs %Integer -> Integer -> Rational numerator the numerator denominator the denominator fromIntegerInteger -> Rational

17. © M. Winter COSC 4P41 – Functional Programming 1. 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. © M. Winter COSC 4P41 – Functional Programming 1. 18 Layout mystery x = x*x +x +2 next x = … fun v1 v2 … vn | g1 = e1 | g2 = e2 … | otherwise = e r

19. © M. Winter COSC 4P41 – Functional Programming 1. 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