# Programming Systems in Artificial Intelligence Functional Programming

Size: px
Start display at page:

Transcription

1 Click to add Text Programming Systems in Artificial Intelligence Functional Programming Siegfried Nijssen 8/03/16 Discover thediscover world at the Leiden world University at Leiden University

2 Overview Foundations: lambda calculus Functional programming languages and their concepts LISP / Scheme Haskell Other languages Foundations: monads

3 Lambda Calculus Based on Rojas, A tutorial on the Lambda calculus Invented by Alonzo Church in the early 1930s Is a universal model of computation and equivalent to the Turing Machine (Church-Turing thesis, 1937) Has a different perspective on performing calculations: Turing machines are built on execution instructions (imperative coding style) Lambda calculus is built on rewriting function applications (declarative coding style) Is the formal basis for functional programming languages

4 Lambda Calculus: Expressions An expression in lambda calculus defined recursively as follows: <expression> := <variable> <function> <application> <function> := ( λ <variable>.<expression> ) <application> := ( <expression> <expression> ) Functions and variables are written down using identifiers Examples of expressions:

5 Lambda Calculus: Notation Brackets around applications can be removed; applications are left associative: Brackets around functions can be removed; the inner expression reaches as far right as possible: A sequence of lambdas is contracted: We can give names to expressions:

6 Lambda Calculus: Free/Bound Variables Lambdas are similar to quantifiers in first-order logic; they bind variables Bound Free Bound Free

7 Lambda Calculus: Substitutions Function applications can be rewritten using substitutions: with Examples: Avoid naming conflicts by renaming variables; expressions with only different variable names are equivalent!

8 Computations using Lambda Calculus Define the following expressions: Then:

9 Computations using Lambda Calculus Define the following expressions: Then:

10 Computations using Lambda Calculus Define the following expressions: Then:

11 Computations using Lambda Calculus Exercise: Calculate the outcome of 2S3

12 Computations using Lambda Calculus Exercise: Calculate the outcome of 2S3

13 LISP List Processing languages: has a large focus on manipulating lists Programming language implementing ideas found in Lambda Calculus Development started in 1957, with many variations existing today Current languages strongly inspired by LISP: Common Lisp (the current standard) Scheme (simplified version of LISP, the basis for the Church probabilistic programming system) Clojure (the basis for the Anglican probabilistic programming system, runs on the Java VM, can use Java libraries)

14 Scheme (Sussman and Steele, 1975) Uses prefix notation similar to Lambda Calculus (+ 3 4 ) (* 5 6 ) (and #T #F) (and (or #T #F) #T) Lambda functions can be defined (lambda (x) (* x x)) And applied: ( (lambda (x) (* x x) ) 7 )

15 Scheme Note: lists are everywhere in LISP (+ 3 4 ) (* 5 6 ) (and #T #F) (and (or #T #F) #T) (lambda (x) (* x x)) ( (lambda (x) (* x x) ) 7 ) List with +, 3, 4 List with and, (or #T #F), #T List with LAMBDA, (x), (* x x) Expressions constructed using (nested) lists, such as in Scheme, are called sexpressions

16 Scheme: Definitions We can give names to expressions (define pi 3.14) (define two_pi (* 2 pi)) This includes lambda expressions ( define f ( lambda ( x y ) ( * x y ) ) ) After which one can write f 3 5

17 Scheme: Definitions There is a shorthand notation for function definitions: ( define f (lambda ( x y ) ( * x y ) ) ) ( define ( f x y ) ( * x y ) ) These definitions are 100% equivalent Scheme is strict: all arguments of a function call must be evaluated before the function is called, and all arguments must be specified These lines will give error messages for both definitions of f, whether or not lambda functions are used: ( f 1 ) ( f )

18 Scheme: Control Flow If statements require a boolean predicate as first parameter (define (factorial n) (if (<= n 1) 1 (* n (factorial ( n 1))) )) Predicates can be defined using functions, and have names ending with? (define (leap? year) (if (zero? (modulo year 400)) #T (if (zero? (modulo year 100)) #F (zero? (modulo year 4)) ) ) ) (leap? 2016)

19 Scheme: Control Flow This long code: (define (leap? year) (if (zero? (modulo year 400)) #T (if (zero? (modulo year 100)) #F (zero? (modulo year 4)) ) ) ) Can be shortened to: (define (leap? year) (cond ((zero? (modulo year 400)) #T) ((zero? (modulo year 100)) #F) (else ( zero? (modulo year 4))) ) )

20 Scheme: List Manipulation The four most important functions manipulating lists are: car L: returns the first element of the list cdr L: returns the tail of the list cons a L: prepends a in front of the list L null? L: test wether the list is empty Example: sum up all elements in a list: (define (add L) (if (null? L) 0 (+ (car L) (add (cdr L)))) (add '(1 3 4)) Note: ' indicates that the list after the ' is not evaluated as a piece of Scheme code, but rather is stored as a list; without ', (1 3 4) would be seen as applying function 1 on arguments 3 and 4, which yields an error

21 Scheme: List Manipulation Given that programs are list, Scheme code can create new code and execute it using an eval function (define (productify L) (cond Treat + as a symbol, not as a function that needs to be evaluated ((null? L) ()) ((list? (car L)) (cons (productify (car L)) (productify (cdr L)))) ((eq? (car L) '+) (cons '* (productify (cdr L)))) (else (cons (car L) (productify (cdr L)))) ) ) ( eval ( productify '(+ 2 ( ) ) (the environment) )

22 Scheme: Exercise Implement a function append that takes two lists as argument and concatenates them (define (append list1 list2) (if (null? list1) list2 (cons (car list1) (append (cdr list1) list2)) ) )

23 Scheme: Map A common function in functional programming is the map function: (define (map fun a_list) (if (null? a_list) () (cons (fun (car a_list)) (map fun (cdr a_list)) ) ) ) Example application: ( map ( lambda (x) (* x x) ) '(1 2 3) )

24 Scheme: Reduce A common function in functional programming is the reduce function: (define (reduce fun a_list) (if (null? (cdr a_list)) (car a_list) (fun (car a_list) (reduce fun (cdr a_list)) ) ) ) Example application: ( reduce ( lambda (x y) (+ x y) ) '(1 2 3) )

25 Scheme: Printing The display function writes its argument to the screen and returns undefined (display ( )) How to call display in a function? (define (add x y) (begin (display x) (display y) (+ x y ) ) ) Starts a block of consecutive function calls This is returned by the code block

26 Scheme: Properties Scheme with IO operations is not pure: If the order of function call evaluation changes, the output of the code changes This makes it hard to parallelize, optimize Scheme notation can be cumbersome Scheme does not have static types (int, float, ) Scheme lacks concepts found in lambda calculus: eg. rewriting of this kind: Up next: languages that address these weaknesses...

27 Haskell Haskell 1.0 was defined in 1990 by a committee of researchers in functional programming Properties: Not strict: not all arguments of a function call do need to be specified; this leads to lazy evaluation Pure: functions do not have side effects; a different order of functional calls will never change the output; Monads are used to deal with side effects Infix notation: infix notation can be used List notation: a more convenient notation for dealing with lists Types: variables and functions have strict types Pattern matching: conditions can be expressed using patterns

28 Haskell: Functions Type definition: factorial :: Integer > Integer Example using IF notation: factorial n = if n > 0 then n * factorial (n 1) else 1 Example using guard notation: factorial n n < 2 = 1 otherwise = n * factorial (n 1)

29 Haskell: Lambda Functions The following two statements are equivalent: increment :: Integer > Integer increment n = n + 1 and increment :: Integer > Integer increment = \n > n + 1

30 Haskell: Lists Prolog-like notation [1, 2, 4] Pattern matching can be used to perform tests on lists, similar to Prolog Example: add :: [Integer] > Integer add [] = 0 add (a:l) = a + add l Function definitions are evaluated top-to-bottom Pattern that matches the head of the list and the tail of the list

31 Haskell: Lists Lists can be created in a similar manner Example: generate :: Integer > [Integer] generate 0 = [] generate n = n : generate (n 1)

32 Haskell: Currying The following code is not strict, as we call the function incr without specifying its two parameters; in that case, a function is returned add :: Integer > Integer > Integer add x y = x + y incr = add 1 main = print (incr 2) Can be read as: integer ( integer integer ) If one integer is given as a parameter, the function returns a function in which x is substituted with the integer, i.e., here the result of add 1 is a lambda function with argument y that returns 1 + y

33 Haskell: Lazy Evaluation Suppose we have the following program: generate :: Integer > [Integer] generate n = n : generate (n + 1) main = print (generate 0) This program will not terminate However, this program terminates: take 0 L = [] take n (a:l) = a : take (n 1) l main = print (take 2 ( generate 0) )

34 Haskell: Lazy Evaluation take 2 ( generate 0 ) take 2 ( 0 : generate (0+1) ) 0 : take (2 1) ( generate (0+1) ) generate n = n : generate (n + 1) take 0 L = [] take n (a:l) = a : take (n 1) l main = print (take 2 ( generate 0) ) 0 : take 1 ( generate (0+1) ) 0 : take 1 ( (0+1) : (generate (0+1+1) ) 0 : take 1 ( 1 : (generate (0+1+1) ) 0 : 1 : take (1 1) (generate (0+1+1) ) 0 : 1 : take 0 (generate (0+1+1) ) 0 : 1 : []

35 Haskell: Lazy Evaluation Strictness can be forced generate :: Integer > [Integer] generate n = let nplus = n + 1 in seq nplus ( n : generate plus ) Syntax can be used to define a term that is used in the body of the function multiple times main = print (generate 0) Forces evaluation

36 Haskell: Data Types Complex data types can be defined in Haskell using type & data constructors Example: binary trees Type constructor Data constructor data Tree a = Tip Node a (Tree a) (Tree a) sumtree :: Num a => Tree a > a As + can only be applied on numericals, sumtree is only defined for Num sumtree Tip = 0 sumtree (Node v a b) = v + sumtree a + sumtree b main = print ( sumtree ( Node 3 ( Node 4 Tip Tip ) Tip ) )

37 Haskell: IO Monad Haskell is pure: functions do not have side effects How to print? Conceptually, an IO monad can be thought of as a type data IO a = RealWorld > (RealWorld,a) Over which certain operations are defined A conceptual data type that reflects the state that the computer is in For instance: The signature of print is: print :: String > IO () The signature of readln is: readln :: IO String Empty

38 Haskell: IO Monad An example of the execution of this code: main = print Hello The type of main is main :: IO () The state of the world before the program is executed is w (print hello ) is a function with signature RealWorld > (RealWorld,()) The Haskell runtime evaluates main by calling it with world w as parameter main w the result is a new world in which Hello is on the screen

39 Haskell: IO Monad Two prints can be combined; in low-level code, as follows: main :: RealWorld > (RealWorld,()) main world0 = let (world1,a) = print Text1 world0 (world2,b) = print Text2 world1 in (world2,()) This code is cumbersome; let us define a new function to make this easier: (>>) c d = \world0 => let (world1,a) = c world0 let (world2,b) = d world1 in (world2,())

40 Haskell: IO Monad This code is cumbersome; let us define a new function to make this easier: (>>) c d = \world0 => let (world1,a) = c world0 let (world2,b) = d world1 in ((), world2) Now we can write: main :: RealWorld > (RealWorld,()) main = (>>) ( print Text1 ) ( print Text2 ) Alternatively, main = print Text1 >> print Text2

41 Haskell: IO Monad Alternatively, main = print Text1 >> print Text2 main = do print Text1 print Text2 Note: in this notation a world object is implicitly passed from the one function call to the other function call functions for which the signature does not include an IO object, can not perform IO

42 Other Monads Alternative definitions of >>, for different Monads, can serve other purposes For example, the Maybe monad: data Maybe t = Just t Nothing div :: Float > Float > Maybe Float div x 0 = Nothing div x y = Just (x/y) docalc :: Maybe Float > Maybe Float > Maybe Float > Maybe Float docalc a b c = do x < a y < b z < c t < div x y div x t

43 Other Functional Programming Languages ML, Miranda: predecessors of Haskell F#, Scala: multi-paradigm languages that include functional primitives def addb(x:int): Int => ( Int => Int ) = ( y => ( z => x + y + z ) ) val a = addb(1)(2)(3) println(a) Factorie, Figaro, Oscar lazy val x = { print ("foo") ; 10 } print ("bar") print (x) print (x) Scala let rec fact x = if x < 1 then 1 else x * fact (x 1) Infer.NET Console.WriteLine(fact 6) F#

44 Overview Lectures 8 march: End of functional programming 1) 15 march: Dyna 2) 22 march: Gringo / Clasp 3) 29 march: ECLiPSe, FO(.) 4) 5 april: Gecode, MiniZinc 5) 12 april: Markov Logic 6)19 april: PRISM, Problog 7) 26 april: Church 8)3 may: Factorie 9)10 may: Tensorflow, Theano

45 Overview Lectures 8 march: End of functional programming 15 march: No lecture 1) 22 march: Dyna Mats Derk, Renuka Ramgolam, - 2) 29 march: ECLiPSe, FO(.) (1), (2), (3) 3) 5 april: Gecode, MiniZinc Jelco Burger, Anne Hommelberg, (4) 4)12 april: Markov Logic Gogou Evangelia, Stellios Paraschiakos, Nick van den Bosch 5) 19 april: Markov Logic Mark Post, +2 6)26 april: PRISM, Problog Hanjo Boekhout, (5), - 7) 3 may: Church, Factorie Raymond Parag, (6), (7) 8)10 may: Tensorflow, Theano Arthur van Rooijen, Lau Bannenberg, -

46 Content Presentation Motivation: discuss applications of the programming system Examples: provide one or more concrete illustrative examples of programs in the programming system, showing code Concepts: discuss on which fundamental concepts the programming system is based Execution: discuss how statements in the programming system are executed Results: show some experimental results reported in the literature (run time, quality,...)

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

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

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

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

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

### 11/6/17. Functional programming. FP Foundations, Scheme (2) LISP Data Types. LISP Data Types. LISP Data Types. Scheme. LISP: John McCarthy 1958 MIT

Functional programming FP Foundations, Scheme (2 In Text: Chapter 15 LISP: John McCarthy 1958 MIT List Processing => Symbolic Manipulation First functional programming language Every version after the

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 16: Functional Programming Zheng (Eddy Zhang Rutgers University April 2, 2018 Review: Computation Paradigms Functional: Composition of operations on data.

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

### Chapter 15. Functional Programming Languages

Chapter 15 Functional Programming Languages Chapter 15 Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming Language: Lisp Introduction

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

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

### Functional Languages. CSE 307 Principles of Programming Languages Stony Brook University

Functional Languages CSE 307 Principles of Programming Languages Stony Brook University http://www.cs.stonybrook.edu/~cse307 1 Historical Origins 2 The imperative and functional models grew out of work

### 4/19/2018. Chapter 11 :: Functional Languages

Chapter 11 :: Functional Languages Programming Language Pragmatics Michael L. Scott Historical Origins The imperative and functional models grew out of work undertaken by Alan Turing, Alonzo Church, Stephen

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

### Functional Languages. Hwansoo Han

Functional Languages Hwansoo Han Historical Origins Imperative and functional models Alan Turing, Alonzo Church, Stephen Kleene, Emil Post, etc. ~1930s Different formalizations of the notion of an algorithm

### Programming Languages

Programming Languages Tevfik Koşar Lecture - XIII March 2 nd, 2006 1 Roadmap Functional Languages Lambda Calculus Intro to Scheme Basics Functions Bindings Equality Testing Searching 2 1 Functional Languages

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

### Functional Programming Lecture 1: Introduction

Functional Programming Lecture 1: Introduction Viliam Lisý Artificial Intelligence Center Department of Computer Science FEE, Czech Technical University in Prague viliam.lisy@fel.cvut.cz Acknowledgements

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

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

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

### Example Scheme Function: equal

ICOM 4036 Programming Languages Functional Programming Languages Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming Language: LISP Introduction to

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

### Chapter 15 Functional Programming Languages

Chapter 15 Functional Programming Languages Fundamentals of Functional Programming Languages Introduction to Scheme A programming paradigm treats computation as the evaluation of mathematical functions.

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 17: Functional Programming Zheng (Eddy Zhang Rutgers University April 4, 2018 Class Information Homework 6 will be posted later today. All test cases

### A Brief Introduction to Scheme (II)

A Brief Introduction to Scheme (II) Philip W. L. Fong pwlfong@cs.uregina.ca Department of Computer Science University of Regina Regina, Saskatchewan, Canada Lists Scheme II p.1/29 Lists Aggregate data

### Chapter 11 :: Functional Languages

Chapter 11 :: Functional Languages Programming Language Pragmatics Michael L. Scott Copyright 2016 Elsevier 1 Chapter11_Functional_Languages_4e - Tue November 21, 2017 Historical Origins The imperative

### Scheme Tutorial. Introduction. The Structure of Scheme Programs. Syntax

Scheme Tutorial Introduction Scheme is an imperative language with a functional core. The functional core is based on the lambda calculus. In this chapter only the functional core and some simple I/O is

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

### Functional Programming Languages (FPL)

Functional Programming Languages (FPL) 1. Definitions... 3 2. Applications... 3 3. Examples... 4 4. FPL Characteristics:... 5 5. Lambda calculus (LC)... 6 5.1. LC expressions forms... 6 5.2. Semantic of

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

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

### Introduction to Functional Programming

Introduction to Functional Programming Xiao Jia xjia@cs.sjtu.edu.cn Summer 2013 Scheme Appeared in 1975 Designed by Guy L. Steele Gerald Jay Sussman Influenced by Lisp, ALGOL Influenced Common Lisp, Haskell,

### FP Foundations, Scheme

FP Foundations, Scheme In Text: Chapter 15 1 Functional Programming -- Prelude We have been discussing imperative languages C/C++, Java, Fortran, Pascal etc. are imperative languages Imperative languages

### Typed Scheme: Scheme with Static Types

Typed Scheme: Scheme with Static Types Version 4.1.1 Sam Tobin-Hochstadt October 5, 2008 Typed Scheme is a Scheme-like language, with a type system that supports common Scheme programming idioms. Explicit

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

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

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

### CS 61A Interpreters, Tail Calls, Macros, Streams, Iterators. Spring 2019 Guerrilla Section 5: April 20, Interpreters.

CS 61A Spring 2019 Guerrilla Section 5: April 20, 2019 1 Interpreters 1.1 Determine the number of calls to scheme eval and the number of calls to scheme apply for the following expressions. > (+ 1 2) 3

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

### From the λ-calculus to Functional Programming Drew McDermott Posted

From the λ-calculus to Functional Programming Drew McDermott drew.mcdermott@yale.edu 2015-09-28 Posted 2015-10-24 The λ-calculus was intended from its inception as a model of computation. It was used by

### SOFTWARE ARCHITECTURE 6. LISP

1 SOFTWARE ARCHITECTURE 6. LISP Tatsuya Hagino hagino@sfc.keio.ac.jp slides URL https://vu5.sfc.keio.ac.jp/sa/ 2 Compiler vs Interpreter Compiler Translate programs into machine languages Compilers are

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

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

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

### Lambda Calculus see notes on Lambda Calculus

Lambda Calculus see notes on Lambda Calculus Shakil M. Khan adapted from Gunnar Gotshalks recap so far: Lisp data structures basic Lisp programming bound/free variables, scope of variables Lisp symbols,

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

### Imperative, OO and Functional Languages A C program is

Imperative, OO and Functional Languages A C program is a web of assignment statements, interconnected by control constructs which describe the time sequence in which they are to be executed. In Java programming,

### 6.184 Lecture 4. Interpretation. Tweaked by Ben Vandiver Compiled by Mike Phillips Original material by Eric Grimson

6.184 Lecture 4 Interpretation Tweaked by Ben Vandiver Compiled by Mike Phillips Original material by Eric Grimson 1 Interpretation Parts of an interpreter Arithmetic calculator

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

### Lecture #24: Programming Languages and Programs

Lecture #24: Programming Languages and Programs A programming language is a notation for describing computations or processes. These range from low-level notations, such as machine language or simple hardware

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

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

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

### CSc 372. Comparative Programming Languages. 2 : Functional Programming. Department of Computer Science University of Arizona

1/37 CSc 372 Comparative Programming Languages 2 : Functional Programming Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2013 Christian Collberg 2/37 Programming Paradigms

### CIS 500 Software Foundations Fall September 25

CIS 500 Software Foundations Fall 2006 September 25 The Lambda Calculus The lambda-calculus If our previous language of arithmetic expressions was the simplest nontrivial programming language, then the

### Harvard School of Engineering and Applied Sciences CS 152: Programming Languages

Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Lecture 18 Thursday, March 29, 2018 In abstract algebra, algebraic structures are defined by a set of elements and operations

### Documentation for LISP in BASIC

Documentation for LISP in BASIC The software and the documentation are both Copyright 2008 Arthur Nunes-Harwitt LISP in BASIC is a LISP interpreter for a Scheme-like dialect of LISP, which happens to have

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

### 1.3. Conditional expressions To express case distinctions like

Introduction Much of the theory developed in the underlying course Logic II can be implemented in a proof assistant. In the present setting this is interesting, since we can then machine extract from a

### Functional Programming

Functional Programming CS 1025 Computer Science Fundamentals I Stephen M. Watt University of Western Ontario When the Function is the Thing In O-O programming, you typically know where an action is needed,

### Chapter 15. Functional Programming Languages ISBN

Chapter 15 Functional Programming Languages ISBN 0-321-49362-1 Chapter 15 Topics Introduction Mathematical Functions Fundamentals of Functional Programming Languages The First Functional Programming Language:

### G Programming Languages - Fall 2012

G22.2110-003 Programming Languages - Fall 2012 Lecture 3 Thomas Wies New York University Review Last week Names and Bindings Lifetimes and Allocation Garbage Collection Scope Outline Control Flow Sequencing

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

### Elixir, functional programming and the Lambda calculus.

Elixir, functional programming and the Lambda calculus. Programming II - Elixir Version Johan Montelius Spring Term 2018 Introduction In this tutorial you re going to explore lambda calculus and how it

### 11/6/17. Outline. FP Foundations, Scheme. Imperative Languages. Functional Programming. Mathematical Foundations. Mathematical Foundations

Outline FP Foundations, Scheme In Text: Chapter 15 Mathematical foundations Functional programming λ-calculus LISP Scheme 2 Imperative Languages We have been discussing imperative languages C/C++, Java,

### Programming Language Pragmatics

Chapter 10 :: Functional Languages Programming Language Pragmatics Michael L. Scott Historical Origins The imperative and functional models grew out of work undertaken Alan Turing, Alonzo Church, Stephen

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

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

### CPL 2016, week 10. Clojure functional core. Oleg Batrashev. April 11, Institute of Computer Science, Tartu, Estonia

CPL 2016, week 10 Clojure functional core Oleg Batrashev Institute of Computer Science, Tartu, Estonia April 11, 2016 Overview Today Clojure language core Next weeks Immutable data structures Clojure simple

### COP4020 Programming Assignment 1 - Spring 2011

COP4020 Programming Assignment 1 - Spring 2011 In this programming assignment we design and implement a small imperative programming language Micro-PL. To execute Mirco-PL code we translate the code to

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

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

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

### Lambda Calculus. Gunnar Gotshalks LC-1

Lambda Calculus LC-1 l- Calculus History Developed by Alonzo Church during 1930 s-40 s One fundamental goal was to describe what can be computed. Full definition of l-calculus is equivalent in power to

### Type Systems Winter Semester 2006

Type Systems Winter Semester 2006 Week 4 November 8 November 15, 2006 - version 1.1 The Lambda Calculus The lambda-calculus If our previous language of arithmetic expressions was the simplest nontrivial

### Haskell 98 in short! CPSC 449 Principles of Programming Languages

Haskell 98 in short! n Syntax and type inferencing similar to ML! n Strongly typed! n Allows for pattern matching in definitions! n Uses lazy evaluation" F definition of infinite lists possible! n Has

### Announcements. The current topic: Scheme. Review: BST functions. Review: Representing trees in Scheme. Reminder: Lab 2 is due on Monday at 10:30 am.

The current topic: Scheme! Introduction! Object-oriented programming: Python Functional programming: Scheme! Introduction! Numeric operators, REPL, quotes, functions, conditionals! Function examples, helper

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

### Principles of Programming Languages 2017W, Functional Programming

Principles of Programming Languages 2017W, Functional Programming Assignment 3: Lisp Machine (16 points) Lisp is a language based on the lambda calculus with strict execution semantics and dynamic typing.

### Introduction to lambda calculus Part 3

Introduction to lambda calculus Part 3 Antti-Juhani Kaijanaho 2017-01-27... 1 Untyped lambda calculus... 2 Typed lambda calculi In an untyped lambda calculus extended with integers, it is required that

PP 2017/18 Unit 12 Functions and Data Types in Haskell 1/45 Programming Paradigms Unit 12 Functions and Data Types in Haskell J. Gamper Free University of Bozen-Bolzano Faculty of Computer Science IDSE

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

1 CSCE 314: Programming Languages Dr. Flemming Andersen Haskell Functions 2 Outline Defining Functions List Comprehensions Recursion 3 Conditional Expressions As in most programming languages, 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,

### Typed Racket: Racket with Static Types

Typed Racket: Racket with Static Types Version 5.0.2 Sam Tobin-Hochstadt November 6, 2010 Typed Racket is a family of languages, each of which enforce that programs written in the language obey a type

### Scheme: Expressions & Procedures

Scheme: Expressions & Procedures CS F331 Programming Languages CSCE A331 Programming Language Concepts Lecture Slides Friday, March 31, 2017 Glenn G. Chappell Department of Computer Science University

### 5. Introduction to the Lambda Calculus. Oscar Nierstrasz

5. Introduction to the Lambda Calculus Oscar Nierstrasz Roadmap > What is Computability? Church s Thesis > Lambda Calculus operational semantics > The Church-Rosser Property > Modelling basic programming

### User-defined Functions. Conditional Expressions in Scheme

User-defined Functions The list (lambda (args (body s to a function with (args as its argument list and (body as the function body. No quotes are needed for (args or (body. (lambda (x (+ x 1 s to the increment

### CSCI-GA Scripting Languages

CSCI-GA.3033.003 Scripting Languages 12/02/2013 OCaml 1 Acknowledgement The material on these slides is based on notes provided by Dexter Kozen. 2 About OCaml A functional programming language All computation

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 18: Functional Programming Zheng (Eddy) Zhang Rutgers University April 9, 2018 Review: Defining Scheme Functions (define ( lambda (

### C311 Lab #3 Representation Independence: Representation Independent Interpreters

C311 Lab #3 Representation Independence: Representation Independent Interpreters Will Byrd webyrd@indiana.edu February 5, 2005 (based on Professor Friedman s lecture on January 29, 2004) 1 Introduction

### Functional programming with Common Lisp

Functional programming with Common Lisp Dr. C. Constantinides Department of Computer Science and Software Engineering Concordia University Montreal, Canada August 11, 2016 1 / 81 Expressions and functions

### Lecture #13: Type Inference and Unification. Typing In the Language ML. Type Inference. Doing Type Inference

Lecture #13: Type Inference and Unification Typing In the Language ML Examples from the language ML: fun map f [] = [] map f (a :: y) = (f a) :: (map f y) fun reduce f init [] = init reduce f init (a ::

### Procedural abstraction SICP Data abstractions. The universe of procedures forsqrt. Procedural abstraction example: sqrt

Data abstractions Abstractions and their variations Basic data abstractions Why data abstractions are useful Procedural abstraction Process of procedural abstraction Define formal parameters, capture process

### 3. Functional Programming. Oscar Nierstrasz

3. Functional Programming Oscar Nierstrasz Roadmap > Functional vs. Imperative Programming > Pattern Matching > Referential Transparency > Lazy Evaluation > Recursion > Higher Order and Curried Functions