# PROGRAMMING IN HASKELL. Chapter 2 - First Steps

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 PROGRAMMING IN HASKELL Chapter 2 - First Steps 0

2 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 for teaching and prototyping purposes; Hugs is available on the web from: 1

3 Starting Hugs On a Unix system, Hugs can be started from the % prompt by simply typing hugs: % hugs Hugs 98: Based on the Haskell 98 standard Copyright (c) World Wide Web: Report bugs to: > 2

4 The Hugs > prompt means that the Hugs system is ready to evaluate an expression. For example: > 2+3*4 14 > (2+3)*4 20 > sqrt (3^2 + 4^2) 5.0 3

5 The Standard Prelude The library file Prelude.hs provides a large number of standard functions. In addition to the familiar numeric functions such as + and *, the library also provides many useful functions on lists. Select the first element of a list: > head [1,2,3,4,5] 1 4

6 Remove the first element from a list: > tail [1,2,3,4,5] [2,3,4,5] Select the nth element of a list: > [1,2,3,4,5]!! 2 3 Select the first n elements of a list: > take 3 [1,2,3,4,5] [1,2,3] 5

7 Remove the first n elements from a list: > drop 3 [1,2,3,4,5] [4,5] Calculate the length of a list: > length [1,2,3,4,5] 5 Calculate the sum of a list of numbers: > sum [1,2,3,4,5] 15 6

8 Calculate the product of a list of numbers: > product [1,2,3,4,5] 120 Append two lists: > [1,2,3] ++ [4,5] [1,2,3,4,5] Reverse a list: > reverse [1,2,3,4,5] [5,4,3,2,1] 7

9 Function Application In mathematics, function application is denoted using parentheses, and multiplication is often denoted using juxtaposition or space. f(a,b) + c d Apply the function f to a and b, and add the result to the product of c and d. 8

10 In Haskell, function application is denoted using space, and multiplication is denoted using *. f a b + c*d As previously, but in Haskell syntax. 9

11 Moreover, function application is assumed to have higher priority than all other operators. f a + b Means (f a) + b, rather than f (a + b). 10

12 Examples Mathematics f(x) f(x,y) f(g(x)) f(x,g(y)) f(x)g(y) Haskell f x f x y f (g x) f x (g y) f x * g y 11

13 Haskell Scripts As well as the functions in the standard prelude, you can also define your own functions; New functions are defined within a script, a text file comprising a sequence of definitions; By convention, Haskell scripts usually have a.hs suffix on their filename. This is not mandatory, but is useful for identification purposes. 12

14 My First Script When developing a Haskell script, it is useful to keep two windows open, one running an editor for the script, and the other running Hugs. Start an editor, type in the following two function definitions, and save the script as test.hs: double x = x + x quadruple x = double (double x) 13

15 Leaving the editor open, in another window start up Hugs with the new script: % hugs test.hs Now both Prelude.hs and test.hs are loaded, and functions from both scripts can be used: > quadruple > take (double 2) [1,2,3,4,5,6] [1,2,3,4] 14

16 Leaving Hugs open, return to the editor, add the following two definitions, and resave: factorial n = product [1..n] average ns = sum ns `div` length ns Note: div is enclosed in back quotes, not forward; x `f` y is just syntactic sugar for f x y. 15

17 Hugs does not automatically detect that the script has been changed, so a reload command must be executed before the new definitions can be used: > :reload Reading file "test.hs" > factorial > average [1,2,3,4,5] 3 16

18 Naming Requirements Function and argument names must begin with a lower-case letter. For example: myfun fun1 arg_2 x By convention, list arguments usually have an s suffix on their name. For example: xs ns nss 17

19 The Layout Rule In a sequence of definitions, each definition must begin in precisely the same column: a = 10 b = 20 c = 30 a = 10 b = 20 c = 30 a = 10 b = 20 c = 30 18

20 The layout rule avoids the need for explicit syntax to indicate the grouping of definitions. a = b + c where b = 1 c = 2 d = a * 2 means a = b + c where {b = 1; c = 2} d = a * 2 implicit grouping explicit grouping 19

21 Useful Hugs Commands Command Meaning :load name load script name :reload reload current script :edit name edit script name :edit edit current script :type expr show type of expr :? show all commands :quit quit Hugs 20

22 Exercises (1) (2) Try out slides 2-8 and using Hugs. Fix the syntax errors in the program below, and test your solution using Hugs. N = a div length xs where a = 10 xs = [1,2,3,4,5] 21

23 (3) Show how the library function last that selects the last element of a list can be defined using the functions introduced in this lecture. (4) Can you think of another possible definition? (5) Similarly, show how the library function init that removes the last element from a list can be defined in two different ways. 22

24 PROGRAMMING IN HASKELL Chapter 3 - Types and Classes 0

25 What is a Type? A type is a name for a collection of related values. For example, in Haskell the basic type Bool contains the two logical values: False True 1

26 Type Errors Applying a function to one or more arguments of the wrong type is called a type error. > 1 + False Error 1 is a number and False is a logical value, but + requires two numbers. 2

27 Types in Haskell If evaluating an expression e would produce a value of type t, then e has type t, written e :: t Every well formed expression has a type, which can be automatically calculated at compile time using a process called type inference. 3

28 All type errors are found at compile time, which makes programs safer and faster by removing the need for type checks at run time. In Hugs, the :type command calculates the type of an expression, without evaluating it: > not False True > :type not False not False :: Bool 4

29 Basic Types Haskell has a number of basic types, including: Bool Char String Int Integer Float - logical values - single characters - strings of characters - fixed-precision integers - arbitrary-precision integers - floating-point numbers 5

30 List Types A list is sequence of values of the same type: [False,True,False] :: [Bool] [ a, b, c, d ] :: [Char] In general: [t] is the type of lists with elements of type t. 6

31 Note: The type of a list says nothing about its length: [False,True] :: [Bool] [False,True,False] :: [Bool] The type of the elements is unrestricted. For example, we can have lists of lists: [[ a ],[ b, c ]] :: [[Char]] 7

32 Tuple Types A tuple is a sequence of values of different types: (False,True) :: (Bool,Bool) (False, a,true) :: (Bool,Char,Bool) In general: (t1,t2,,tn) is the type of n-tuples whose ith components have type ti for any i in 1 n. 8

33 Note: The type of a tuple encodes its size: (False,True) :: (Bool,Bool) (False,True,False) :: (Bool,Bool,Bool) The type of the components is unrestricted: ( a,(false, b )) :: (Char,(Bool,Char)) (True,[ a, b ]) :: (Bool,[Char]) 9

34 Function Types A function is a mapping from values of one type to values of another type: not :: Bool Bool isdigit :: Char Bool In general: t1 t2 is the type of functions that map values of type t1 to values to type t2. 10

35 Note: The arrow is typed at the keyboard as ->. The argument and result types are unrestricted. For example, functions with multiple arguments or results are possible using lists or tuples: add :: (Int,Int) Int add (x,y) = x+y zeroto zeroto n :: Int [Int] = [0..n] 11

36 Curried Functions Functions with multiple arguments are also possible by returning functions as results: add add x y = x+y :: Int (Int Int) add takes an integer x and returns a function add x. In turn, this function takes an integer y and returns the result x+y. 12

37 Note: add and add produce the same final result, but add takes its two arguments at the same time, whereas add takes them one at a time: add :: (Int,Int) Int add :: Int (Int Int) Functions that take their arguments one at a time are called curried functions, celebrating the work of Haskell Curry on such functions. 13

38 Functions with more than two arguments can be curried by returning nested functions: mult mult x y z = x*y*z :: Int (Int (Int Int)) mult takes an integer x and returns a function mult x, which in turn takes an integer y and returns a function mult x y, which finally takes an integer z and returns the result x*y*z. 14

39 Why is Currying Useful? Curried functions are more flexible than functions on tuples, because useful functions can often be made by partially applying a curried function. For example: add 1 :: Int Int take 5 :: [Int] [Int] drop 5 :: [Int] [Int] 15

40 Currying Conventions To avoid excess parentheses when using curried functions, two simple conventions are adopted: The arrow associates to the right. Int Int Int Int Means Int (Int (Int Int)). 16

41 As a consequence, it is then natural for function application to associate to the left. mult x y z Means ((mult x) y) z. Unless tupling is explicitly required, all functions in Haskell are normally defined in curried form. 17

42 Polymorphic Functions A function is called polymorphic ( of many forms ) if its type contains one or more type variables. length :: [a] Int for any type a, length takes a list of values of type a and returns an integer. 18

43 Note: Type variables can be instantiated to different types in different circumstances: > length [False,True] 2 > length [1,2,3,4] 4 a = Bool a = Int Type variables must begin with a lower-case letter, and are usually named a, b, c, etc. 19

44 Many of the functions defined in the standard prelude are polymorphic. For example: fst :: (a,b) a head :: [a] a take :: Int [a] [a] zip :: [a] [b] [(a,b)] id :: a a 20

45 Overloaded Functions A polymorphic function is called overloaded if its type contains one or more class constraints. sum :: Num a [a] a for any numeric type a, sum takes a list of values of type a and returns a value of type a. 21

46 Note: Constrained type variables can be instantiated to any types that satisfy the constraints: > sum [1,2,3] 6 > sum [1.1,2.2,3.3] 6.6 > sum [ a, b, c ] ERROR a = Int a = Float Char is not a numeric type 22

47 Haskell has a number of type classes, including: Num - Numeric types Eq - Equality types Ord - Ordered types For example: (+) :: Num a a a a (==) :: Eq a a a Bool (<) :: Ord a a a Bool 23

48 Hints and Tips When defining a new function in Haskell, it is useful to begin by writing down its type; Within a script, it is good practice to state the type of every new function defined; When stating the types of polymorphic functions that use numbers, equality or orderings, take care to include the necessary class constraints. 24

49 Exercises (1) What are the types of the following values? [ a, b, c ] ( a, b, c ) [(False, 0 ),(True, 1 )] ([False,True],[ 0, 1 ]) [tail,init,reverse] 25

50 (2) What are the types of the following functions? second xs swap (x,y) pair x y = head (tail xs) = (y,x) = (x,y) double x = x*2 palindrome xs = reverse xs == xs twice f x = f (f x) (3) Check your answers using Hugs. 26

51 PROGRAMMING IN HASKELL Chapter 4 - Defining Functions 0

52 Conditional Expressions As in most programming languages, functions can be defined using conditional expressions. abs :: Int Int abs n = if n 0 then n else -n abs takes an integer n and returns n if it is non-negative and -n otherwise. 1

53 Conditional expressions can be nested: signum :: Int Int signum n = if n < 0 then -1 else if n == 0 then 0 else 1 Note: In Haskell, conditional expressions must always have an else branch, which avoids any possible ambiguity problems with nested conditionals. 2

54 Guarded Equations As an alternative to conditionals, functions can also be defined using guarded equations. abs n n 0 = n otherwise = -n As previously, but using guarded equations. 3

55 Guarded equations can be used to make definitions involving multiple conditions easier to read: signum n n < 0 = -1 n == 0 = 0 otherwise = 1 Note: The catch all condition otherwise is defined in the prelude by otherwise = True. 4

56 Pattern Matching Many functions have a particularly clear definition using pattern matching on their arguments. not :: Bool Bool not False = True not True = False not maps False to True, and True to False. 5

57 Functions can often 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 6

58 However, the following definition is more efficient, because it avoids evaluating the second argument if the first argument is False: True && b = b False && _ = False Note: The underscore symbol _ is a wildcard pattern that matches any argument value. 7

59 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 8

60 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:[]))). 9

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

62 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 11

63 Integer Patterns As in mathematics, functions on integers can be defined using n+k patterns, where n is an integer variable and k>0 is an integer constant. pred :: Int Int pred (n+1) = n pred maps any positive integer to its predecessor. 12

64 Note: n+k patterns only match integers k. > pred 0 Error n+k patterns must be parenthesised, because application has priority over +. For example, the following definition gives an error: pred n+1 = n 13

65 Lambda Expressions Functions can be constructed without naming the functions by using lambda expressions. x x+x the nameless function that takes a number x and returns the result x+x. 14

66 Note: 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. 15

67 Why Are Lambda's Useful? Lambda expressions can be used to give a formal meaning to functions defined using currying. For example: add x y = x+y means add = x ( y x+y) 16

68 Lambda expressions are also useful when defining functions that return functions as results. For example: const :: a b a const x _ = x is more naturally defined by const :: a (b a) const x = _ x 17

69 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*2 + 1 can be simplified to odds n = map ( x x*2 + 1) [0..n-1] 18

70 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: > > (+)

71 This convention also allows one of the arguments of the operator to be included in the parentheses. For example: > (1+) 2 3 > (+2) 1 3 In general, if is an operator then functions of the form ( ), (x ) and ( y) are called sections. 20

72 Why Are Sections Useful? Useful functions can sometimes be constructed in a simple way using sections. For example: (1+) (1/) (*2) (/2) - successor function - reciprocation function - doubling function - halving function 21

73 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) a conditional expression; (b) guarded equations; (c) pattern matching. Hint: the library function null :: [a] Bool can be used to test if a list is empty. 22

74 (2) (3) Give three possible definitions for the logical or operator ( ) using pattern matching. 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 23

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

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

PROGRAMMING IN HASKELL Chapter 2 - First Steps 0 Glasgow Haskell Compiler GHC is the leading implementation of Haskell, and comprises a compiler and interpreter; The interactive nature of the interpreter

### CSCE 314 Programming Languages

CSCE 314 Programming Languages Haskell 101 Dr. Hyunyoung Lee 1 Contents 1. Historical Background of Haskell 2. Lazy, Pure, and Functional Language 3. Using ghc and ghci 4. Functions 5. Haskell Scripts

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

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

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

### 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:

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

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

### CSE 3302 Programming Languages Lecture 8: Functional Programming

CSE 3302 Programming Languages Lecture 8: Functional Programming (based on the slides by Tim Sheard) Leonidas Fegaras University of Texas at Arlington CSE 3302 L8 Spring 2011 1 Functional Programming Languages

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

### Redefinition of an identifier is OK, but this is redefinition not assignment; Thus

Redefinition of an identifier is OK, but this is redefinition not assignment; Thus val x = 100; val x = (x=100); is fine; there is no type error even though the first x is an integer and then it is a boolean.

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

### Introduction to Functional Programming in Haskell 1 / 56

Introduction to Functional Programming in Haskell 1 / 56 Outline Why learn functional programming? The essence of functional programming What is a function? Equational reasoning First-order vs. higher-order

### COSE212: Programming Languages. Lecture 3 Functional Programming in OCaml

COSE212: Programming Languages Lecture 3 Functional Programming in OCaml Hakjoo Oh 2017 Fall Hakjoo Oh COSE212 2017 Fall, Lecture 3 September 18, 2017 1 / 44 Why learn ML? Learning ML is a good way of

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

### News. Programming Languages. Complex types: Lists. Recap: ML s Holy Trinity. CSE 130: Spring 2012

News CSE 130: Spring 2012 Programming Languages On webpage: Suggested HW #1 PA #1 (due next Fri 4/13) Lecture 2: A Crash Course in ML Please post questions to Piazza Ranjit Jhala UC San Diego Today: A

### According to Larry Wall (designer of PERL): a language by geniuses! for geniuses. Lecture 7: Haskell. Haskell 98. Haskell (cont) - Type-safe!

Lecture 7: Haskell CSC 131 Fall, 2014 Kim Bruce According to Larry Wall (designer of PERL): a language by geniuses for geniuses He s wrong at least about the latter part though you might agree when we

Overloading, Type Classes, and Algebraic Datatypes Delivered by Michael Pellauer Arvind Computer Science and Artificial Intelligence Laboratory M.I.T. September 28, 2006 September 28, 2006 http://www.csg.csail.mit.edu/6.827

### CHAPTER 4 FUNCTIONS. 4.1 Introduction

CHAPTER 4 FUNCTIONS 4.1 Introduction Functions are the building blocks of C++ programs. Functions are also the executable segments in a program. The starting point for the execution of a program is main

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

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

### Haskell-Tutorial. Damir Medak Gerhard Navratil. Institute for Geoinformation Technical University Vienna. February 2003

Haskell-Tutorial Damir Medak Gerhard Navratil Institute for Geoinformation Technical University Vienna February 2003 There are numerous books on functional programming. These books are good, but usually

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

### COMP80 Lambda Calculus Programming Languages Slides Courtesy of Prof. Sam Guyer Tufts University Computer Science History Big ideas Examples:

COMP80 Programming Languages Slides Courtesy of Prof. Sam Guyer Lambda Calculus Formal system with three parts Notation for functions Proof system for equations Calculation rules called reduction Idea:

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

### Introduction to Typed Racket. The plan: Racket Crash Course Typed Racket and PL Racket Differences with the text Some PL Racket Examples

Introduction to Typed Racket The plan: Racket Crash Course Typed Racket and PL Racket Differences with the text Some PL Racket Examples Getting started Find a machine with DrRacket installed (e.g. the

### Option Values, Arrays, Sequences, and Lazy Evaluation

Option Values, Arrays, Sequences, and Lazy Evaluation Björn Lisper School of Innovation, Design, and Engineering Mälardalen University bjorn.lisper@mdh.se http://www.idt.mdh.se/ blr/ Option Values, Arrays,

### CSCE 314 Programming Languages. Functional Parsers

CSCE 314 Programming Languages Functional Parsers Dr. Hyunyoung Lee 1 What is a Parser? A parser is a program that takes a text (set of tokens) and determines its syntactic structure. String or [Token]

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

### CS 457/557: Functional Languages

CS 457/557: Functional Languages From Trees to Type Classes Mark P Jones Portland State University 1 Trees:! " There are many kinds of tree data structure.! " For example: data BinTree a = Leaf a BinTree

### Tuples. CMSC 330: Organization of Programming Languages. Examples With Tuples. Another Example

CMSC 330: Organization of Programming Languages OCaml 2 Higher Order Functions Tuples Constructed using (e1,..., en) Deconstructed using pattern matching Patterns involve parens and commas, e.g., (p1,p2,

### Data types for mcrl2

Data types for mcrl2 Aad Mathijssen April 5, 2018 We provide a syntax for the standard data types of the mcrl2 language. This syntax is intended to be a practical mix between standard mathematical notation

About the Tutorial Haskell is a widely used purely functional language. Functional programming is based on mathematical functions. Besides Haskell, some of the other popular languages that follow Functional

### Topic 5: Higher Order Functions

Topic 5: Higher Order Functions 1 Recommended Exercises and Readings From Haskell: The craft of functional programming (3 rd Ed.) Exercises: 10.1, 10.2, 10.3, 10.4, 10.5, 10.6, 10.7, 10.8, 10.9, 10.10,

T O Y H Advances in Programming Languages APL8: Multiparameter Type Classes, Constructor Classes Ian Stark School of Informatics The University of Edinburgh Thursday 4 February Semester 2 Week 4 E H U

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

### Plan (next 4 weeks) 1. Fast forward. 2. Rewind. 3. Slow motion. Rapid introduction to what s in OCaml. Go over the pieces individually

Plan (next 4 weeks) 1. Fast forward Rapid introduction to what s in OCaml 2. Rewind 3. Slow motion Go over the pieces individually History, Variants Meta Language Designed by Robin Milner @ Edinburgh Language

### cs242 Kathleen Fisher Reading: Concepts in Programming Languages, Chapter 6 Thanks to John Mitchell for some of these slides.

cs242 Kathleen Fisher Reading: Concepts in Programming Languages, Chapter 6 Thanks to John Mitchell for some of these slides. We are looking for homework graders. If you are interested, send mail to cs242cs.stanford.edu

### Lists. Adrian Groza. Department of Computer Science Technical University of Cluj-Napoca

Lists Adrian Groza Department of Computer Science Technical University of Cluj-Napoca Recall... Parameter evaluation Call-by-value Call-by-name Call-by-need Functions Infix operators Local declarations,

Advanced features of Functional Programming (Haskell) Polymorphism and overloading January 10, 2017 Monomorphic and polymorphic types A (data) type specifies a set of values. Examples: Bool: the type of

### Type system. Type theory. Haskell type system. EDAN40: Functional Programming Types and Type Classes (revisited)

Type system EDAN40: Functional Programming Types and Type Classes (revisited) Jacek Malec Dept. of Computer Science, Lund University, Sweden April 3rd, 2017 In programming languages, a type system is a

### CS 209 Functional Programming

CS 209 Functional Programming Lecture 03 - Intro to Monads Dr. Greg Lavender Department of Computer Science Stanford University "The most important thing in a programming language is the name. A language

### Processadors de Llenguatge II. Functional Paradigm. Pratt A.7 Robert Harper s SML tutorial (Sec II)

Processadors de Llenguatge II Functional Paradigm Pratt A.7 Robert Harper s SML tutorial (Sec II) Rafael Ramirez Dep Tecnologia Universitat Pompeu Fabra Paradigm Shift Imperative Paradigm State Machine

### Functional Programming

Functional Programming COMS W4115 Prof. Stephen A. Edwards Spring 2003 Columbia University Department of Computer Science Original version by Prof. Simon Parsons Functional vs. Imperative Imperative programming

### Scheme: Data. CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, April 3, Glenn G.

Scheme: Data CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, April 3, 2017 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks ggchappell@alaska.edu

### 15 150: Principles of Functional Programming. More about Higher-Order Functions

15 150: Principles of Functional Programming More about Higher-Order Functions Michael Erdmann Spring 2018 1 Topics Currying and uncurrying Staging computation Partial evaluation Combinators 2 Currying

### Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003

Principles of Programming Languages Topic: Functional Programming Professor L. Thorne McCarty Spring 2003 CS 314, LS, LTM: Functional Programming 1 Scheme A program is an expression to be evaluated (in

### Thoughts on Assignment 4 Haskell: Flow of Control

Thoughts on Assignment 4 Haskell: Flow of Control CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Monday, February 27, 2017 Glenn G. Chappell Department of Computer

Haskell Overloading (1) LiU-FP2016: Lecture 8 Type Classes Henrik Nilsson University of Nottingham, UK What is the type of (==)? E.g. the following both work: 1 == 2 a == b I.e., (==) can be used to compare

### A quick introduction to SML

A quick introduction to SML CMSC 15300 April 9, 2004 1 Introduction Standard ML (SML) is a functional language (or higherorder language) and we will use it in this course to illustrate some of the important

### Spring 2018 Discussion 7: March 21, Introduction. 2 Primitives

CS 61A Scheme Spring 2018 Discussion 7: March 21, 2018 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

### Type Checking and Type Inference

Type Checking and Type Inference Principles of Programming Languages CSE 307 1 Types in Programming Languages 2 Static Type Checking 3 Polymorphic Type Inference Version: 1.8 17:20:56 2014/08/25 Compiled

### Programming Languages

CSE 130 : Winter 2013 Programming Languages Lecture 3: Crash Course, Datatypes Ranjit Jhala UC San Diego 1 Story So Far... Simple Expressions Branches Let-Bindings... Today: Finish Crash Course Datatypes

### A tour of the Haskell Prelude

A tour of the Haskell Prelude Bernie Pope 2001 1 Haskell The Haskell language was conceived during a meeting held at the 1987 Functional Programming and Computer Architecture conference (FPCA 87). At the

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

CIS552: Advanced Programming Handout 8 What is a Parser? A parser is a program that analyzes a piece of text to deine its structure (and, typically, returns a tree representing this structure). The World

### Control Structures. Lecture 4 COP 3014 Fall September 18, 2017

Control Structures Lecture 4 COP 3014 Fall 2017 September 18, 2017 Control Flow Control flow refers to the specification of the order in which the individual statements, instructions or function calls

### CS152: Programming Languages. Lecture 7 Lambda Calculus. Dan Grossman Spring 2011

CS152: Programming Languages Lecture 7 Lambda Calculus Dan Grossman Spring 2011 Where we are Done: Syntax, semantics, and equivalence For a language with little more than loops and global variables Now:

### Functional Programming TDA 452, DIT 142

Chalmers Göteborgs Universitet 2018-01-11 Examiner: Thomas Hallgren, D&IT, Answering questions at approx 15.00 (or by phone) Functional Programming TDA 452, DIT 142 2018-01-11 14.00 18.00 Samhällsbyggnad

### Recursion and Induction

Recursion and Induction Jayadev Misra The University of Texas at Austin December 5, 2003 Contents 1 Introduction 2 2 Primitive Data Types 3 3 Writing Function Definitions 6 3.1 Loading Program Files........................

### Computer Programming

Computer Programming Introduction Marius Minea marius@cs.upt.ro http://cs.upt.ro/ marius/curs/cp/ 26 September 2017 Course goals Learn programming fundamentals no prior knowledge needed for those who know,

### Data Types The ML Type System

7 Data Types 7.2.4 The ML Type System The following is an ML version of the tail-recursive Fibonacci function introduced Fibonacci function in ML in Section 6.6.1: EXAMPLE 7.96 1. fun fib (n) = 2. let

### Conversion vs. Subtyping. Lecture #23: Conversion and Type Inference. Integer Conversions. Conversions: Implicit vs. Explicit. Object x = "Hello";

Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). In Java, this is legal: Object x = "Hello";

### Whereweare. CS-XXX: Graduate Programming Languages. Lecture 7 Lambda Calculus. Adding data structures. Data + Code. What about functions

Whereweare CS-XXX: Graduate Programming Languages Lecture 7 Lambda Calculus Done: Syntax, semantics, and equivalence For a language with little more than loops and global variables Now: Didn t IMP leave

### Basic types and definitions. Chapter 3 of Thompson

Basic types and definitions Chapter 3 of Thompson Booleans [named after logician George Boole] Boolean values True and False are the result of tests are two numbers equal is one smaller than the other

### Scheme: Strings Scheme: I/O

Scheme: Strings Scheme: I/O CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Wednesday, April 5, 2017 Glenn G. Chappell Department of Computer Science University of

### Week 5 Tutorial Structural Induction

Department of Computer Science, Australian National University COMP2600 / COMP6260 Formal Methods in Software Engineering Semester 2, 2016 Week 5 Tutorial Structural Induction You should hand in attempts

### Scheme as implemented by Racket

Scheme as implemented by Racket (Simple view:) Racket is a version of Scheme. (Full view:) Racket is a platform for implementing and using many languages, and Scheme is one of those that come out of the

### Intro to Haskell Notes: Part 1

Intro to Haskell Notes: Part 1 Adrian Brasoveanu July 1, 2013 Contents 1 Comments 2 2 Simple arithmetic 2 3 Boolean operators 2 4 Testing for equality 3 5 No covert type conversion 3 6 Functions 4 6.1

### Fundamentals of Artificial Intelligence COMP221: Functional Programming in Scheme (and LISP)

Fundamentals of Artificial Intelligence COMP221: Functional Programming in Scheme (and LISP) Prof. Dekai Wu Department of Computer Science and Engineering The Hong Kong University of Science and Technology

CSci 450: Org. of Programming Languages Overloading and Type Classes H. Conrad Cunningham 27 October 2017 (after class) Contents 9 Overloading and Type Classes 1 9.1 Chapter Introduction.........................

### GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]

GADTs Advanced functional programming - Lecture 7 Wouter Swierstra and Alejandro Serrano 1 Today s lecture Generalized algebraic data types (GADTs) 2 A datatype data Tree a = Leaf Node (Tree a) a (Tree

### CSE 505. Lecture #9. October 1, Lambda Calculus. Recursion and Fixed-points. Typed Lambda Calculi. Least Fixed Point

Lambda Calculus CSE 505 Lecture #9 October 1, 2012 Expr ::= Var λ Var. Expr (Expr Expr) Key Concepts: Bound and Free Occurrences Substitution, Reduction Rules: α, β, η Confluence and Unique Normal Form

### Programming with Math and Logic

.. Programming with Math and Logic an invitation to functional programming Ed Morehouse Wesleyan University The Plan why fp? terms types interfaces The What and Why of Functional Programming Computing

### Principles of Programming Languages COMP251: Functional Programming in Scheme (and LISP)

Principles of Programming Languages COMP251: Functional Programming in Scheme (and LISP) Prof. Dekai Wu Department of Computer Science and Engineering The Hong Kong University of Science and Technology

### Recap from last time. Programming Languages. CSE 130 : Fall Lecture 3: Data Types. Put it together: a filter function

CSE 130 : Fall 2011 Recap from last time Programming Languages Lecture 3: Data Types Ranjit Jhala UC San Diego 1 2 A shorthand for function binding Put it together: a filter function # let neg = fun f

### Functional Programming. Pure Functional Languages

Functional Programming Pure functional PLs S-expressions cons, car, cdr Defining functions read-eval-print loop of Lisp interpreter Examples of recursive functions Shallow, deep Equality testing 1 Pure

### Haskell Making Our Own Types and Typeclasses

Haskell Making Our Own Types and Typeclasses http://igm.univ-mlv.fr/~vialette/?section=teaching Stéphane Vialette LIGM, Université Paris-Est Marne-la-Vallée January 13, 2015 Making Our Own Types and Typeclasses

### Types, Type Inference and Unification

Types, Type Inference and Unification Mooly Sagiv Slides by Kathleen Fisher and John Mitchell Cornell CS 6110 Summary (Functional Programming) Lambda Calculus Basic ML Advanced ML: Modules, References,

### Tree Equality: The Problem

Recall the tree data type we defined: Tree Equality: The Problem data LTree a = LLeaf a LBranch (LTree a) (LTree a) Suppose we want to write a function that determines if two trees are equal: treeeq (LLeaf

### Introduction to C# Applications

1 2 3 Introduction to C# Applications OBJECTIVES To write simple C# applications To write statements that input and output data to the screen. To declare and use data of various types. To write decision-making

### Functions. Lab 4. Introduction: A function : is a collection of statements that are grouped together to perform an operation.

Lab 4 Functions Introduction: A function : is a collection of statements that are grouped together to perform an operation. The following is its format: type name ( parameter1, parameter2,...) { statements

### CIS 194: Homework 4. Due Wednesday, February 18, What is a Number?

CIS 194: Homework 4 Due Wednesday, February 18, 2015 What is a Number? This may sound like a deep, philosophical question, but the Haskell type system gives us a simple way to answer it. A number is any

### Tokens, Expressions and Control Structures

3 Tokens, Expressions and Control Structures Tokens Keywords Identifiers Data types User-defined types Derived types Symbolic constants Declaration of variables Initialization Reference variables Type

### An informal tutorial on Joy 1

An informal tutorial on Joy 1 Manfred von Thun Abstract: Joy is a functional programming language which is not based on the application of functions to arguments but on the composition of functions. It

### COMP 250: Java Programming I. Carlos G. Oliver, Jérôme Waldispühl January 17-18, 2018 Slides adapted from M. Blanchette

COMP 250: Java Programming I Carlos G. Oliver, Jérôme Waldispühl January 17-18, 2018 Slides adapted from M. Blanchette Variables and types [Downey Ch 2] Variable: temporary storage location in memory.

### COMPUTER SCIENCE 123. Foundations of Computer Science. 5. Strings

COMPUTER SCIENCE 123 Foundations of Computer Science 5. Strings Summary: This lecture introduces strings in Haskell. You should also have: Tutorial sheet 2 Solutions to Tutorial sheet 1 Lab sheet 3 Solutions

### These notes are intended exclusively for the personal usage of the students of CS352 at Cal Poly Pomona. Any other usage is prohibited without

These notes are intended exclusively for the personal usage of the students of CS352 at Cal Poly Pomona. Any other usage is prohibited without previous written authorization. 1 2 The simplest way to create

### Chapter 3 Linear Structures: Lists

Plan Chapter 3 Linear Structures: Lists 1. Lists... 3.2 2. Basic operations... 3.4 3. Constructors and pattern matching... 3.5 4. Polymorphism... 3.8 5. Simple operations on lists... 3.11 6. Application:

### PROGRAMMING IN HASKELL. Chapter 10 - Interactive Programming

PROGRAMMING IN HASKELL Chapter 10 - Interactive Programming 0 Introduction To date, we have seen how Haskell can be used to write batch programs that take all their inputs at the start and give all their

### More Lambda Calculus and Intro to Type Systems

More Lambda Calculus and Intro to Type Systems Plan Heavy Class Participation Thus, wake up! Lambda Calculus How is it related to real life? Encodings Fixed points Type Systems Overview Static, Dyamic

### CIS 194: Homework 6. Due Monday, February 25. Fibonacci numbers

CIS 194: Homework 6 Due Monday, February 25 Files you should submit: Fibonacci.hs This week we learned about Haskell s lazy evaluation. This homework assignment will focus on one particular consequence

### CSC324- TUTORIAL 5. Shems Saleh* *Some slides inspired by/based on Afsaneh Fazly s slides

CSC324- TUTORIAL 5 ML Shems Saleh* *Some slides inspired by/based on Afsaneh Fazly s slides Assignment 1 2 More questions were added Questions regarding the assignment? Starting ML Who am I? Shems Saleh

### INFOB3TC Solutions for the Exam

Department of Information and Computing Sciences Utrecht University INFOB3TC Solutions for the Exam Johan Jeuring Monday, 13 December 2010, 10:30 13:00 lease keep in mind that often, there are many possible

### Programming Language Concepts, CS2104 Lecture 7

Reminder of Last Lecture Programming Language Concepts, CS2104 Lecture 7 Tupled Recursion Exceptions Types, ADT, Haskell, Components 5th Oct 2007 CS2104, Lecture 7 1 Overview 5th Oct 2007 CS2104, Lecture

### Programming in Haskell Aug-Nov 2015

Programming in Haskell Aug-Nov 2015 LECTURE 5 AUGUST 18, 2015 S P SURESH CHENNAI MATHEMATICAL INSTITUTE The datatype Char Values are written with single quotes a, 3, %, #, Character symbols stored in a