# CSCE 314 TAMU Fall CSCE 314: Programming Languages Dr. Flemming Andersen. Haskell Functions

Size: px
Start display at page:

Transcription

1 1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Functions

2 2 Outline Defining Functions List Comprehensions Recursion

3 3 Conditional Expressions As in most programming languages, functions can be defined using conditional expressions: if cond then e1 else e2 e1 and e2 must be of the same type else branch is always present abs :: Int -> Int abs n = if n >= 0 then n else n max :: Int -> Int -> Int max x y = if x <= y then y else x take :: Int -> [a] -> [a] take n xs = if n <= 0 then [] else if xs == [] then [] else (head xs) : take (n-1) (tail xs)

4 Guarded Equations As an alternative to conditionals, functions can also be defined using guarded equations. abs n n >= 0 = n otherwise = -n Prelude: otherwise = True Guarded equations can be used to make definitions involving multiple conditions easier to read: signum n n < 0 = -1 n == 0 = 0 otherwise = 1 compare with signum n = if n < 0 then -1 else if n == 0 then 0 else 1 4

5 5 Guarded Equations (Cont.) Guards and patterns can be freely mixed, the first equation whose pattern matches and guard is satisfied is chosen. take :: Int -> [a] -> [a] take n xs n <= 0 = [] take n [] = [] take n (x:xs) = x : take (n-1) xs

6 6 Pattern Matching Many functions are defined using pattern matching on their arguments. not not False = True :: Bool -> Bool not True = False not maps False to True, and True to False. Pattern can be a constant value, or include one or more variables.

7 Functions can be defined in many different ways using pattern matching. For example (&&) :: Bool Bool Bool True && True = True True && False = False False && True = False False && False = False can be defined more compactly by True && True = True _ && _ = False However, the following definition is more efficient, because it avoids evaluating the second argument if the first argument is False: False && _ = False True && b = b The underscore symbol _ is a wildcard pattern that matches any argument value. 7

8 8 Patterns are matched in order. For example, the following definition always returns False: _ && _ = False True && True = True Patterns may not repeat variables. For example, the following definition gives an error: b && b = b _ && _ = False

9 9 List Patterns Internally, every non-empty list is constructed by repeated use of an operator (:) called cons that adds an element to the start of a list. [1,2,3,4] Means 1:(2:(3:(4:[]))). Functions on lists can be defined using x:xs patterns. head :: [a] a head (x:_) = x tail :: [a] [a] tail (_:xs) = xs head and tail map any non-empty list to its first and remaining elements. is this definition complete?

10 10 Note: x:xs patterns only match non-empty lists: > head [] Error x:xs patterns must be parenthesised, because application has priority over (:). For example, the following definition gives an error: head x:_ = x Patterns can contain arbitrarily deep structure: f (_: (_, x):_) = x g [[_]] = True

11 11 Totality of Functions (Total) function maps every element in the function s domain to an element in its codomain. Partial function maps zero or more elements in the function s domain to an element in its codomain, and can leave some elements undefined. Haskell functions can be partial. For example: head (x:_) = x > head [] *** Exception: Prelude.head: empty list > "10elements"!! 10 *** Exception: Prelude.(!!): index too large

12 12 Lambda Expressions Functions can be constructed without naming the functions by using lambda expressions. λx x+x This nameless function takes a number x and returns the result x+x. The symbol λ is the Greek letter lambda, and is typed at the keyboard as a backslash \. In mathematics, nameless functions are usually denoted using the symbol, as in x x+x. In Haskell, the use of the λ symbol for nameless functions comes from the lambda calculus, the theory of functions on which Haskell is based.

13 13 Why are Lambda's Useful? 1. Lambda expressions can be used to give a formal meaning to functions defined using currying. For example: means add x y = x + y square x = x * x add = \x -> (\y -> x + y) square = \x -> x * x

14 14 2. Lambda expressions can be used to avoid naming functions that are only referenced once. For example: odds n = map f [0..n-1] where f x = x * can be simplified to odds n = map (\x -> x * 2 + 1) [0..n-1] 3. Lambda expressions can be bound to a name (function argument) incrementer = \x -> x + 1 add (incrementer 5) 6

15 15 (1) Case Expressions take m ys = case (m, ys) of (n, _) n <= 0 -> [] (_, []) -> [] (n, x:xs) -> x : take (m-1) xs Pattern matching need not be tied to function definitions; they also work with case expressions. For example: (2) length [] = 0 length (_:xs) = 1 + length xs using a case expression and a lambda: length = \ls -> case ls of [] -> 0 (_:xs) -> 1 + length xs

16 (1) Let and Where The let and where clauses are used to create a local scope within a function. For example: reserved s = -- using let let keywords = words if then else for while relops = words ==!= < > <= >= eleminany w [] = False eleminany w (l:ls) = w `elem` l eleminany w ls in eleminany s [keywords, relops] (2) reserved s = -- using where eleminany s [keywords, relops] where keywords = words if then else for while... eleminany w (l:ls) = w `elem` l eleminany w ls unzip :: [(a, b)] -> ([a], [b]) unzip [] = ([], []) unzip ((a, b):rest) = let (as, bs) = unzip rest in (a:as, b:bs) 16

17 17 Let vs. Where The let in is an expression, whereas where blocks are declarations bound to the context. For example: f x -- using where block cond1 x = a cond2 x = g a otherwise = f (h x a) where a = w x f x -- using let-in expression = let a = w x in case () of _ cond1 x -> a cond2 x -> g a otherwise -> f (h x a)

18 18 Sections An operator written between its two arguments can be converted into a curried function written before its two arguments by using parentheses. For example: > > (+) This convention also allows one of the arguments of the operator to be included in the parentheses. For example: > (1+) 2 > (+2) In general, if is an operator then functions of the form ( ), (x ) and ( y) are called sections.

19 19 Why Are Sections Useful? Useful functions can sometimes be constructed in a simple way using sections. For example: (1+) (1/) (*2) (/2) - successor function (\y->1+y) - reciprocal function - doubling function - halving function Sometimes it is convenient or necessary to pass an operator as a parameter or when stating its type

20 20 Exercises (1) Consider a function safetail that behaves in the same way as tail, except that safetail maps the empty list to the empty list, whereas tail gives an error in this case. Define safetail using: (a) (b) (c) a conditional expression; guarded equations; pattern matching. Hint: the library function null :: [a] Bool can be used to test if a list is empty.

21 21 (2) Give three possible definitions for the logical or operator ( ) using pattern matching. (3) Redefine the following version of (&&) using conditionals rather than patterns: True && True = True _ && _ = False (4) Do the same for the following version: True && b = b False && _ = False

22 22 Outline Defining Functions List Comprehensions Recursion

23 23 List Comprehensions A convenient syntax for defining lists Set comprehension - In mathematics, the comprehension notation can be used to construct new sets from old sets. E.g., {(x 2,y 2 ) x {1,2,...,10}, y {1,2,...,10}, x 2 +y 2 101} Same in Haskell: new lists from old lists [(x^2, y^2) x <- [1..10], y <- [1..10], x^2 + y^2 <= 101] generates: [(1,1),(1,4),(1,9),(1,16),(1,25),(1,36),(1,49),(1,64),(1,81),(1,1 00),(4,1),(4,4),(4,9),(4,16),(4,25),(4,36),(4,49),(4,64),(4,81),(9,1),(9,4),(9,9),(9,16),(9,25),(9,36),(9,49),(9,64),(9,81),(16,1),(16,4),(16,9),(16,16),(16,25),(16,36),(16,49),(16,64),(16,81),(25,1),(25,4),(25,9),(25,16),(25,25),(25, 36),(25,49),(25,64),(36,1),(36,4),(36,9),(36,16),(36,25),(36,36),(36,49),(36,64),(49,1),(49,4),(49,9),(49,16),(49,25),(49,36),(49,49),(64,1),(64,4),(64,9),(64,16),(64,25),(64,36),(81,1),(81,4),(81,9),(81,16),(100,1)]

24 List Comprehensions: Generators The expression x <- [1..10] is called a generator, as it states how to generate values for x. generators can be infinite, e.g., > take 3 [x x <- [1..]] [1,2,3] Comprehensions can have multiple generators, separated by commas. For example: > [(x,y) x <- [1,2,3], y <- [4,5]] [(1,4),(1,5),(2,4),(2,5),(3,4),(3,5)] Multiple generators are like nested loops, with later generators as more deeply nested loops whose variables change value more frequently. 24

25 25 For example: > [(x,y) y <- [4,5], x <- [1,2,3]] [(1,4),(2,4),(3,4),(1,5),(2,5),(3,5)] x [1,2,3] is the last generator, so the value of the x component of each pair changes most frequently.

26 Dependent Generators Later generators can depend on the variables that are introduced by earlier generators. [(x,y) x <- [1..3], y <- [x..3]] The list [(1,1),(1,2),(1,3),(2,2),(2,3),(3,3)] of all pairs of numbers (x,y) such that x and y are elements of the list [1..3] and y x. Using a dependant generator we can define the library function that concatenates a list of lists: concat :: [[a]] -> [a] concat xss = [x xs <- xss, x <- xs] > concat [[1,2,3],[4,5],[6]] [1,2,3,4,5,6] 26

27 Guards List comprehensions can use guards to restrict the values produced by earlier generators. [x x <- [1..10], even x] list all numbers x s.t. x is an element of the list [1..10] and x is even Example: Using a guard we can define a function that maps a positive integer to its list of factors: factors :: Int -> [Int] factors n = [x x <- [1..n], n `mod` x == 0] > factors 15 [1,3,5,15] 27

28 A positive integer is prime if its only factors are 1 and itself. Hence, using factors we can define a function that decides if a number is prime: prime :: Int -> Bool prime n = factors n == [1,n] > prime 15 False > prime 7 True Using a guard we can now define a function that returns the list of all primes up to a given limit: primes :: Int -> [Int] primes n = [x x <- [2..n], prime x] > primes 40 [2,3,5,7,11,13,17,19,23,29,31,37] 28

29 The Zip Function A useful library function is zip, which maps two lists to a list of pairs of their corresponding elements. zip :: [a] -> [b] -> [(a,b)] > zip [ a, b, c ] [1,2,3,4] [( a,1),( b,2),( c,3)] Using zip we can define a function that returns the list of all positions of a value in a list: positions :: Eq a => a -> [a] -> [Int] positions x xs = [i (x,i) <- zip xs [0..n], x == x ] where n = length xs - 1 > positions 0 [1,0,0,1,0,1,1,0] [1,2,4,7] 29

30 Using zip we can define a function that returns the list of all pairs of adjacent elements from a list: pairs :: [a] -> [(a,a)] pairs xs = zip xs (tail xs) > pairs [1,2,3,4] [(1,2),(2,3),(3,4)] Using pairs we can define a function that decides if the elements in a list are sorted: sorted :: Ord a => [a] -> Bool sorted xs = and [x y (x,y) <- pairs xs] > sorted [1,2,3,4] True > sorted [1,3,2,4] False 30

31 Exercises (1) A triple (x,y,z) of positive integers is called pythagorean if x 2 + y 2 = z 2. Using a list comprehension, define a function pyths :: Int -> [(Int,Int,Int)] that maps an integer n to all such triples with components in [1..n]. For example: > pyths 5 [(3,4,5),(4,3,5)] pyths n = [(x,y,z) x<-[1..n], y<-[1..n], z<-[1..n], x^2+y^2==z^2] 31

32 32 (2) A positive integer is perfect if it equals the sum of all of its factors, excluding the number itself. Using a list comprehension, define a function perfects :: Int [Int] that returns the list of all perfect numbers up to a given limit. For example: > perfects 500 [6,28,496]

33 33 (3) The scalar product of two lists of integers xs and ys of length n is given by the sum of the products of the corresponding integers: n-1 i = 0 (xs i * ys i ) Using a list comprehension, define a function that returns the scalar product of two lists. scalarproduct :: [Int] -> [Int] -> Int scalarproduct xs ys = sum[x*y (x,y) <- zip xs ys]

### Shell CSCE 314 TAMU. Haskell Functions

1 CSCE 314: Programming Languages Dr. Dylan Shell Haskell Functions 2 Outline Defining Functions List Comprehensions Recursion 3 Conditional Expressions As in most programming languages, functions can

### PROGRAMMING IN HASKELL. Chapter 5 - List Comprehensions

PROGRAMMING IN HASKELL Chapter 5 - List Comprehensions 0 Set Comprehensions In mathematics, the comprehension notation can be used to construct new sets from old sets. {x 2 x {1...5}} The set {1,4,9,16,25}

### PROGRAMMING IN HASKELL. Chapter 2 - First Steps

PROGRAMMING IN HASKELL Chapter 2 - First Steps 0 The Hugs System Hugs is an implementation of Haskell 98, and is the most widely used Haskell system; The interactive nature of Hugs makes it well suited

### Shell CSCE 314 TAMU. Functions continued

1 CSCE 314: Programming Languages Dr. Dylan Shell Functions continued 2 Outline Defining Functions List Comprehensions Recursion 3 A Function without Recursion Many functions can naturally be defined in

### INTRODUCTION TO FUNCTIONAL PROGRAMMING

INTRODUCTION TO FUNCTIONAL PROGRAMMING Graham Hutton University of Nottingham adapted by Gordon Uszkay 1 What is Functional Programming? Opinions differ, and it is difficult to give a precise definition,

### PROGRAMMING IN HASKELL. CS Chapter 6 - Recursive Functions

PROGRAMMING IN HASKELL CS-205 - Chapter 6 - Recursive Functions 0 Introduction As we have seen, many functions can naturally be defined in terms of other functions. factorial :: Int Int factorial n product

### A general introduction to Functional Programming using Haskell

A general introduction to Functional Programming using Haskell Matteo Rossi Dipartimento di Elettronica e Informazione Politecnico di Milano rossi@elet.polimi.it 1 Functional programming in a nutshell

### Lecture 19: Functions, Types and Data Structures in Haskell

The University of North Carolina at Chapel Hill Spring 2002 Lecture 19: Functions, Types and Data Structures in Haskell Feb 25 1 Functions Functions are the most important kind of value in functional programming

### Haskell Overview II (2A) Young Won Lim 8/23/16

(2A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published

### Haskell Overview II (2A) Young Won Lim 8/9/16

(2A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published

### An introduction introduction to functional functional programming programming using usin Haskell

An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dkau Haskell The most popular p purely functional, lazy programming g language Functional programming language : a program

### Standard prelude. Appendix A. A.1 Classes

Appendix A Standard prelude In this appendix we present some of the most commonly used definitions from the standard prelude. For clarity, a number of the definitions have been simplified or modified from

### Haskell Types, Classes, and Functions, Currying, and Polymorphism

1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Types, Classes, and Functions, Currying, and Polymorphism 2 Types A type is a collection of related values. For example, Bool contains the

### CS 457/557: Functional Languages

CS 457/557: Functional Languages Lists and Algebraic Datatypes Mark P Jones Portland State University 1 Why Lists? Lists are a heavily used data structure in many functional programs Special syntax is

### Haske k ll An introduction to Functional functional programming using Haskell Purely Lazy Example: QuickSort in Java Example: QuickSort in Haskell

Haskell An introduction to functional programming using Haskell Anders Møller amoeller@cs.au.dk The most popular purely functional, lazy programming language Functional programming language : a program

### CS 320: Concepts of Programming Languages

CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 04: Basic Haskell Continued o Polymorphic Types o Type Inference with Polymorphism o Standard

### Haskell: Lists. CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Friday, February 24, Glenn G.

Haskell: Lists CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Friday, February 24, 2017 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks

### Haskell Overview II (2A) Young Won Lim 9/26/16

(2A) Copyright (c) 2016 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published

### CSc 372 Comparative Programming Languages

CSc 372 Comparative Programming Languages 8 : Haskell Function Examples Christian Collberg collberg+372@gmail.com Department of Computer Science University of Arizona Copyright c 2005 Christian Collberg

### CSc 372. Comparative Programming Languages. 8 : Haskell Function Examples. Department of Computer Science University of Arizona

1/43 CSc 372 Comparative Programming Languages 8 : Haskell Function Examples Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2013 Christian Collberg Functions over Lists

### Shell CSCE 314 TAMU. Higher Order Functions

1 CSCE 314: Programming Languages Dr. Dylan Shell Higher Order Functions 2 Higher-order Functions A function is called higher-order if it takes a function as an argument or returns a function as a result.

### CSCE 314 Programming Languages

CSCE 314 Programming Languages Final Review Part I Dr. Hyunyoung Lee 1 Programming Language Characteristics Different approaches to describe computations, to instruct computing devices E.g., Imperative,

### The List Datatype. CSc 372. Comparative Programming Languages. 6 : Haskell Lists. Department of Computer Science University of Arizona

The List Datatype CSc 372 Comparative Programming Languages 6 : Haskell Lists Department of Computer Science University of Arizona collberg@gmail.com All functional programming languages have the ConsList

### CSC312 Principles of Programming Languages : Functional Programming Language. Copyright 2006 The McGraw-Hill Companies, Inc.

CSC312 Principles of Programming Languages : Functional Programming Language Overview of Functional Languages They emerged in the 1960 s with Lisp Functional programming mirrors mathematical functions:

### Functional Programming in Haskell for A level teachers

Functional Programming in Haskell for A level teachers About this document Functional Programming is now part of the A level curriculum. This document is intended to get those who already have some programming

### It is better to have 100 functions operate one one data structure, than 10 functions on 10 data structures. A. Perlis

Chapter 14 Functional Programming Programming Languages 2nd edition Tucker and Noonan It is better to have 100 functions operate one one data structure, than 10 functions on 10 data structures. A. Perlis

INTRODUCTION TO HASKELL PRINCIPLES OF PROGRAMMING LANGUAGES Norbert Zeh Winter 2018 Dalhousie University 1/81 HASKELL: A PURELY FUNCTIONAL PROGRAMMING LANGUAGE Functions are first-class values: Can be

### Background Operators (1E) Young Won Lim 7/7/18

Background Operators (1E) Copyright (c) 2016-2018 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2

### CSCE 314 Programming Languages

CSCE 314 Programming Languages Haskell: Higher-order Functions Dr. Hyunyoung Lee 1 Higher-order Functions A function is called higher-order if it takes a function as an argument or returns a function as

### Lecture 2: List algorithms using recursion and list comprehensions

Lecture 2: List algorithms using recursion and list comprehensions Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense September 12, 2017 Expressions, patterns

### Imperative languages

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

### CS 320: Concepts of Programming Languages

CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 06: Useful Haskell Syntax, HO Programming Continued o Goodbye to Bare Bones Haskell: Built-in

### Fall 2018 Discussion 8: October 24, 2018 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 208 Discussion 8: October 24, 208 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

### Lists. Michael P. Fourman. February 2, 2010

Lists Michael P. Fourman February 2, 2010 1 Introduction The list is a fundamental datatype in most functional languages. ML is no exception; list is a built-in ML type constructor. However, to introduce

### COP4020 Programming Languages. Functional Programming Prof. Robert van Engelen

COP4020 Programming Languages Functional Programming Prof. Robert van Engelen Overview What is functional programming? Historical origins of functional programming Functional programming today Concepts

### n n Try tutorial on front page to get started! n spring13/ n Stack Overflow!

Announcements n Rainbow grades: HW1-6, Quiz1-5, Exam1 n Still grading: HW7, Quiz6, Exam2 Intro to Haskell n HW8 due today n HW9, Haskell, out tonight, due Nov. 16 th n Individual assignment n Start early!

### Organization of Programming Languages CS3200/5200N. Lecture 11

Organization of Programming Languages CS3200/5200N Razvan C. Bunescu School of Electrical Engineering and Computer Science bunescu@ohio.edu Functional vs. Imperative The design of the imperative languages

### Higher Order Functions in Haskell

Higher Order Functions in Haskell Evan Misshula 2018-09-10 Outline Curried Functions Curried comparison Example partial application partial application of a string function Returned functions ZipWith flip

### LECTURE 16. Functional Programming

LECTURE 16 Functional Programming WHAT IS FUNCTIONAL PROGRAMMING? Functional programming defines the outputs of a program as a mathematical function of the inputs. Functional programming is a declarative

### CS 440: Programming Languages and Translators, Spring 2019 Mon

Haskell, Part 4 CS 440: Programming Languages and Translators, Spring 2019 Mon 2019-01-28 More Haskell Review definition by cases Chapter 6: Higher-order functions Revisit currying map, filter Unnamed

### CSc 372. Comparative Programming Languages. 15 : Haskell List Comprehension. Department of Computer Science University of Arizona

1/20 CSc 372 Comparative Programming Languages 15 : Haskell List Comprehension Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2013 Christian Collberg 2/20 List Comprehensions

### Lecture 4: Higher Order Functions

Lecture 4: Higher Order Functions Søren Haagerup Department of Mathematics and Computer Science University of Southern Denmark, Odense September 26, 2017 HIGHER ORDER FUNCTIONS The order of a function

### Introduction. chapter Functions

chapter 1 Introduction In this chapter we set the stage for the rest of the book. We start by reviewing the notion of a function, then introduce the concept of functional programming, summarise the main

### This example highlights the difference between imperative and functional programming. The imperative programming solution is based on an accumulator

1 2 This example highlights the difference between imperative and functional programming. The imperative programming solution is based on an accumulator (total) and a counter (i); it works by assigning

### CMSC 330: Organization of Programming Languages. Operational Semantics

CMSC 330: Organization of Programming Languages Operational Semantics Notes about Project 4, Parts 1 & 2 Still due today (7/2) Will not be graded until 7/11 (along with Part 3) You are strongly encouraged

### Haskell: From Basic to Advanced. Part 2 Type Classes, Laziness, IO, Modules

Haskell: From Basic to Advanced Part 2 Type Classes, Laziness, IO, Modules Qualified types In the types schemes we have seen, the type variables were universally quantified, e.g. ++ :: [a] -> [a] -> [a]

### Box-and-arrow Diagrams

Box-and-arrow Diagrams 1. Draw box-and-arrow diagrams for each of the following statements. What needs to be copied, and what can be referenced with a pointer? (define a ((squid octopus) jelly sandwich))

### Informatics 1 Functional Programming Lecture 11. Data Representation. Don Sannella University of Edinburgh

Informatics 1 Functional Programming Lecture 11 Data Representation Don Sannella University of Edinburgh Part I Complexity t = n vs t = n 2 10.4 9.6 8.8 8 7.2 6.4 5.6 4.8 4 3.2 2.4 1.6 0.8 0 0.8 1.6 2.4

### Haskell through HUGS THE BASICS

Haskell through HUGS THE BASICS FP for DB Basic HUGS 1 Algorithmic Imperative Languages variables assignment if condition then action1 else action2 loop block while condition do action repeat action until

### Functional Programming

Functional Programming CS331 Chapter 14 Functional Programming Original functional language is LISP LISt Processing The list is the fundamental data structure Developed by John McCarthy in the 60 s Used

### CPS 506 Comparative Programming Languages. Programming Language Paradigm

CPS 506 Comparative Programming Languages Functional Programming Language Paradigm Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming

### CSCE 314 Programming Languages

CSCE 314 Programming Languages Haskell: Declaring Types and Classes Dr. Hyunyoung Lee 1 Outline Declaring Data Types Class and Instance Declarations 2 Defining New Types Three constructs for defining types:

### SML A F unctional Functional Language Language Lecture 19

SML A Functional Language Lecture 19 Introduction to SML SML is a functional programming language and acronym for Standard d Meta Language. SML has basic data objects as expressions, functions and list

### Informatics 1 Functional Programming Lecture 4. Lists and Recursion. Don Sannella University of Edinburgh

Informatics 1 Functional Programming Lecture 4 Lists and Recursion Don Sannella University of Edinburgh Part I Lists and Recursion Cons and append Cons takes an element and a list. Append takes two lists.

### CS 360: Programming Languages Lecture 12: More Haskell

CS 360: Programming Languages Lecture 12: More Haskell Geoffrey Mainland Drexel University Adapted from Brent Yorgey s course Introduction to Haskell. Section 1 Administrivia Administrivia Homework 5 due

PP 2017/18 Unit 11 Functional Programming with Haskell 1/37 Programming Paradigms Unit 11 Functional Programming with Haskell J. Gamper Free University of Bozen-Bolzano Faculty of Computer Science IDSE

### List Functions, and Higher-Order Functions

List Functions, and Higher-Order Functions Björn Lisper Dept. of Computer Science and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ List Functions, and Higher-Order

### CSCE 314 TAMU Fall CSCE 314: Programming Languages Dr. Flemming Andersen. Haskell Basics

1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Basics 2 Contents 1. Jump into Haskell: Using ghc and ghci (more detail) 2. Historical Background of Haskell 3. Lazy, Pure, and Functional

Functional Programming and Haskell Tim Dawborn University of Sydney, Australia School of Information Technologies Tim Dawborn Functional Programming and Haskell 1/22 What are Programming Paradigms? A programming

### Declaring Numbers. Bernd Braßel, Frank Huch and Sebastian Fischer. Department of Computer Science, University of Kiel, Germany

Declaring Numbers Bernd Braßel, Frank Huch and Sebastian Fischer Department of Computer Science, University of Kiel, Germany WFLP 2007, Paris, France I m going to present joint work with my colleagues

### Haskell Introduction Lists Other Structures Data Structures. Haskell Introduction. Mark Snyder

Outline 1 2 3 4 What is Haskell? Haskell is a functional programming language. Characteristics functional non-strict ( lazy ) pure (no side effects*) strongly statically typed available compiled and interpreted

### Scheme. Functional Programming. Lambda Calculus. CSC 4101: Programming Languages 1. Textbook, Sections , 13.7

Scheme Textbook, Sections 13.1 13.3, 13.7 1 Functional Programming Based on mathematical functions Take argument, return value Only function call, no assignment Functions are first-class values E.g., functions

### SCHEME 8. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. March 23, 2017

SCHEME 8 COMPUTER SCIENCE 61A March 2, 2017 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### CS 11 Haskell track: lecture 1

CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission of

### Programming Language Concepts: Lecture 14

Programming Language Concepts: Lecture 14 Madhavan Mukund Chennai Mathematical Institute madhavan@cmi.ac.in http://www.cmi.ac.in/~madhavan/courses/pl2009 PLC 2009, Lecture 14, 11 March 2009 Function programming

### Informatics 1 Functional Programming Lecture 12. Data Abstraction. Don Sannella University of Edinburgh

Informatics 1 Functional Programming Lecture 12 Data Abstraction Don Sannella University of Edinburgh Part I Sets as lists without abstraction We will look again at our four ways of implementing sets.

### CMSC 330: Organization of Programming Languages. Functional Programming with Lists

CMSC 330: Organization of Programming Languages Functional Programming with Lists 1 Lists in OCaml The basic data structure in OCaml Lists can be of arbitrary length Implemented as a linked data structure

### Functional Programming. Pure Functional Programming

Functional Programming Pure Functional Programming Computation is largely performed by applying functions to values. The value of an expression depends only on the values of its sub-expressions (if any).

### Putting the fun in functional programming

CM20167 Topic 4: Map, Lambda, Filter Guy McCusker 1W2.1 Outline 1 Introduction to higher-order functions 2 Map 3 Lambda 4 Filter Guy McCusker (1W2.1 CM20167 Topic 4 2 / 42 Putting the fun in functional

### Introduction to Programming, Aug-Dec 2006

Introduction to Programming, Aug-Dec 2006 Lecture 3, Friday 11 Aug 2006 Lists... We can implicitly decompose a list into its head and tail by providing a pattern with two variables to denote the two components

### State Monad (3D) Young Won Lim 9/25/17

Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published

### EDAF40. 2nd June :00-19:00. WRITE ONLY ON ONE SIDE OF THE PAPER - the exams will be scanned in and only the front/ odd pages will be read.

EDAF40 2nd June 2017 14:00-19:00 WRITE ONLY ON ONE SIDE OF THE PAPER - the exams will be scanned in and only the front/ odd pages will be read. DO NOT WRITE WITH OTHER COLOUR THAN BLACK - coloured text

### Functional Programming. Big Picture. Design of Programming Languages

Functional Programming Big Picture What we ve learned so far: Imperative Programming Languages Variables, binding, scoping, reference environment, etc What s next: Functional Programming Languages Semantics

### Functional Programming. Overview. Topics. Definition n-th Fibonacci Number. Graph

Topics Functional Programming Christian Sternagel Harald Zankl Evgeny Zuenko Department of Computer Science University of Innsbruck WS 2017/2018 abstract data types, algebraic data types, binary search

### Functional Programming. Overview. Topics. Recall λ-terms. Examples

Topics Functional Programming Christian Sternagel Harald Zankl Evgeny Zuenko Department of Computer Science University of Innsbruck WS 2017/2018 abstract data types, algebraic data types, binary search

### Exercise 1 ( = 22 points)

1 Exercise 1 (4 + 3 + 4 + 5 + 6 = 22 points) The following data structure represents polymorphic lists that can contain values of two types in arbitrary order: data DuoList a b = C a (DuoList a b) D b

### CSc 520 Principles of Programming Languages. Currying Revisited... Currying Revisited. 16: Haskell Higher-Order Functions

Higher-Order Functions CSc 520 Principles of Programming Languages 16: Haskell Higher-Order Functions Christian Collberg collberg@cs.arizona.edu Department of Computer Science University of Arizona Copyright

### Fall 2017 Discussion 7: October 25, 2017 Solutions. 1 Introduction. 2 Primitives

CS 6A Scheme Fall 207 Discussion 7: October 25, 207 Solutions Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write

### CSc 372. Comparative Programming Languages. 11 : Haskell Higher-Order Functions. Department of Computer Science University of Arizona

CSc 372 Comparative Programming Languages 11 : Haskell Higher-Order Functions Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2010 Christian Collberg Higher-Order Functions

### Programming Languages Fall 2013

Programming Languages Fall 2013 Lecture 2: types Prof. Liang Huang huang@qc.cs.cuny.edu Recap of Lecture 1 functional programming vs. imperative programming basic Haskell syntax function definition lazy

### OCaml. ML Flow. Complex types: Lists. Complex types: Lists. The PL for the discerning hacker. All elements must have same type.

OCaml The PL for the discerning hacker. ML Flow Expressions (Syntax) Compile-time Static 1. Enter expression 2. ML infers a type Exec-time Dynamic Types 3. ML crunches expression down to a value 4. Value

### CMSC 330: Organization of Programming Languages. Functional Programming with Lists

CMSC 330: Organization of Programming Languages Functional Programming with Lists CMSC330 Spring 2018 1 Lists in OCaml The basic data structure in OCaml Lists can be of arbitrary length Implemented as

Haskell An Introduction What is Haskell? General purpose Purely functional No function can have side-effects IO is done using special types Lazy Strongly typed Polymorphic types Concise and elegant A First

### Advanced Topics in Programming Languages Lecture 2 - Introduction to Haskell

Advanced Topics in Programming Languages Lecture 2 - Introduction to Haskell Ori Bar El Maxim Finkel 01/11/17 1 History Haskell is a lazy, committee designed, pure functional programming language that

### Informatics 1 Functional Programming Lecture 7. Map, filter, fold. Don Sannella University of Edinburgh

Informatics 1 Functional Programming Lecture 7 Map, filter, fold Don Sannella University of Edinburgh Part I Map Squares *Main> squares [1,-2,3] [1,4,9] squares :: [Int] -> [Int] squares xs [ x*x x

### Programming Languages

Programming Languages Lambda Calculus and Scheme CSCI-GA.2110-003 Fall 2011 λ-calculus invented by Alonzo Church in 1932 as a model of computation basis for functional languages (e.g., Lisp, Scheme, ML,

### Wellesley College CS251 Programming Languages Spring, 2000 FINAL EXAM REVIEW PROBLEM SOLUTIONS

Wellesley College CS251 Programming Languages Spring, 2000 FINAL EXAM REVIEW PROBLEM SOLUTIONS This document contains solutions to the problems on the final exam review problems posted earlier except for

### List Processing in Ocaml

CS251 Programming Languages Handout # 14 Prof. Lyn Turbak February 2, 2007 Wellesley College List Processing in Ocaml Given a list of integers ns, suppose we want to return a new list of the same length

### SCHEME 7. 1 Introduction. 2 Primitives COMPUTER SCIENCE 61A. October 29, 2015

SCHEME 7 COMPUTER SCIENCE 61A October 29, 2015 1 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Summer 2017 Discussion 10: July 25, Introduction. 2 Primitives and Define

CS 6A Scheme Summer 207 Discussion 0: July 25, 207 Introduction In the next part of the course, we will be working with the Scheme programming language. In addition to learning how to write Scheme programs,

### Solution sheet 1. Introduction. Exercise 1 - Types of values. Exercise 2 - Constructors

Solution sheet 1 Introduction Please note that there can be other solutions than those listed in this document. This is a literate Haskell file which is available as PDF, as well as literate Haskell source

### Functional Programming Languages (FPL)

Functional Programming Languages (FPL) 1. Definitions... 2 2. Applications... 2 3. Examples... 3 4. FPL Characteristics:... 3 5. Lambda calculus (LC)... 4 6. Functions in FPLs... 7 7. Modern functional

### Functional Logic Programming Language Curry

Functional Logic Programming Language Curry Xiang Yin Department of Computer Science McMaster University November 9, 2010 Outline Functional Logic Programming Language 1 Functional Logic Programming Language

### Polymorphic lambda calculus Princ. of Progr. Languages (and Extended ) The University of Birmingham. c Uday Reddy

06-02552 Princ. of Progr. Languages (and Extended ) The University of Birmingham Spring Semester 2016-17 School of Computer Science c Uday Reddy2016-17 Handout 6: Polymorphic Type Systems 1. Polymorphic

### A Second Look At ML. Chapter Seven Modern Programming Languages, 2nd ed. 1

A Second Look At ML Chapter Seven Modern Programming Languages, 2nd ed. 1 Outline Patterns Local variable definitions A sorting example Chapter Seven Modern Programming Languages, 2nd ed. 2 Two Patterns

### Let s Talk About Logic

Let s Talk About Logic Jan van Eijck CWI & ILLC, Amsterdam Masterclass Logica, 2 Maart 2017 Abstract This lecture shows how to talk about logic in computer science. To keep things simple, we will focus