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

Size: px
Start display at page:

Download "Functional Languages. CSE 307 Principles of Programming Languages Stony Brook University"

Transcription

1 Functional Languages CSE 307 Principles of Programming Languages Stony Brook University 1

2 Historical Origins 2 The imperative and functional models grew out of work undertaken Alan Turing, Alonzo Church, Stephen Kleene, Emil Post, etc. ~1930s different formalizations of the notion of an algorithm, or effective procedure, based on automata, symbolic manipulation, recursive function definitions, and combinatorics These results led Church to conjecture that any intuitively appealing model of computing would be equally powerful as well this conjecture is known as Church s thesis

3 Historical Origins Turing s model of computing was the Turing machine a sort of pushdown automaton using an unbounded storage tape the Turing machine computes in an imperative way, by changing the values in cells of its tape like variables just as a high level imperative program computes by changing the values of variables 3

4 Historical Origins 4 Church s model of computing is called the lambda calculus based on the notion of parameterized expressions with each parameter introduced by an occurrence of the letter λ. Lambda calculus was the inspiration for functional programming. Computation by substitution of parameters into expressions, just as computation by passing arguments to functions. Constructive proof that transforms input into output

5 Lambda Calculus λ = lambda lambda terms consist of: variables (a) lambda abstraction (λa.t) application (t s) Variables can be bound by lambda abstractions or free: Example: in λa.ab, a is bound, b is free. 5

6 Lambda Calculus alpha equivalence: λa.a = λb.b beta substitution: (λa.aa) b = bb problem: what happens if we substitute a free variable into a place where it would be bound? Example: (λa.(λb.ab)) b c wrong: (λb.λb) c cc right: use alpha equivalence to ensure this doesn't happen. (λa.(λd.ad)) b c (λd.bd) c bc 6

7 Functional Programming Concepts Functional languages such as Lisp, Scheme, FP, ML, Miranda, and Haskell are an attempt to realize Church's lambda calculus in practical form as a programming language The key idea: do everything by composing functions no mutable state no side effects So how do you get anything done in a functional language? Recursion takes the place of iteration First-call functions take value inputs Higher-order functions take a function as input 7

8 Functional Programming Concepts Recursion even does a nifty job of replacing looping x := 0; i := 1; j := 100; while i < j do x := x + i*j; i := i + 1; j := j - 1 end while return x becomes f(0,1,100), where f(x,i,j) == if i < j then f (x+i*j, i+1, j-1) else x 8

9 Functional Programming Concepts Necessary features, many of which are missing in some imperative languages: high-order functions powerful list facilities structured function returns fully general aggregates garbage collection 9

10 Functional Programming Concepts 10 LISP family of programming languages: Pure (original) Lisp Interlisp, MacLisp, Emacs Lisp Common Lisp Scheme All of them use s-expression syntax: (+ 1 2). LISP is old - dates back to only Fortran is older. Anything in parentheses is a function call (unless quoted) (+ 1 2) evaluates to 3 ((+ 1 2)) <- error, since 3 is not a function. by default, s-expressions are evaluated. We can use the quote special form to stop that: (quote (1 2 3)) short form: '(1 2 3) is a list containing +, 1, 2

11 Functional Programming Concepts Pure Lisp is purely functional; all other Lisps have imperative features All early Lisps: dynamically scoped Not clear whether this was deliberate or if it happened by accident Scheme and Common Lisp are statically scoped Common Lisp provides dynamic scope as an option for explicitly-declared special functions Common Lisp now THE standard Lisp Very big; complicated 11

12 A Review/Overview of Scheme Interpreter runs a read-eval-print loop Things typed into the interpreter are evaluated (recursively) once Names: Scheme is generally a lot more liberal with the names it allows: foo? bar+ baz- <--- all valid names x\$_%l&=*! <--- valid name names by default evaluate to their value 12

13 A Review/Overview of Scheme 13 Conditional expressions: (if a b c) = if a then b else c Example: (if (< 2 3) 4 5) 4 Example 2: only one of the sub-expressions evaluates (based on if the condition is true): (if (> a b) (- a 100) (- b 100)) Imperative stuff assignments sequencing (begin) iteration I/O (read, display)

14 A Review/Overview of Scheme Lamba expressions: (lambda (x) (* x x)) We can apply one or more parameters to it: ((lambda (x) (* x x)) 3) (* 3 3) 9 Bindings: (let ((a 1) (b 2)) (+ a b)) in let, all names are bound at once. So if we did: (let ((a 1) (b a)) (+ a b)) we'd get name from outer scope. It prevents recursive calls. letrec puts bindings into effect while being computed (allows for recursive calls): (letrec ((fac (lambda (x) (if (= x 0) 1 (* x (fac (- x 1))))))) (fac 10)) 14

15 A Review/Overview of Scheme Define binds a name in the global scope: (define square (lambda (x) (* x x))) Lists: pull apart lists: (car '(1 2 3)) -> 1 (cdr '(1 2 3)) -> (2 3) (cons 1 '(2 3)) -> (1 2 3) Equality testing: (= a b) <- numeric equality (eq? 1 2) <- shallow comparison (equal? a b) <- deep comparison 15

16 A Review/Overview of Scheme Control-flow: (begin (display "foo") (display "bar") ) Special functions: eval = takes a list and evaluates it. A list: '(+ 1 2) -> (+ 1 2) Evaluation of a list: (eval '(+ 1 2)) -> 3 apply = take a lambda and list: calls the function with the list as an argument. 16

17 A Review/Overview of Scheme Evaluation order: applicative order: evaluates arguments before passing them to a function: ((lambda (x) (* x x)) (+ 1 2)) ((lambda (x) (* x x) 3) (* 3 3) 9 normal order: passes in arguments before evaluating them: ((lambda (x) (* x x)) (+ 1 2)) (* (+ 1 2) (+ 1 2)) (* 3 3) 9 Note: we might want normal order in some code. (if-tuesday (do-tuesday)) // do-tuesday might print something and we want it only if it s Tuesday 17

18 A Review/Overview of Scheme 18 ((lambda (x y) (if x (+ y y) 0) t (* 10 10)) Applicative order: ((lambda (x y) (if x (+ y y)) t 100) (if t ( ) 0) ( ) 200 (four steps!) Normal Order: (if t (+ (* 10 10) (* 10 10)) 0) (+ (* 10 10) (* 10 10)) (+ 100 (* 10 10)) ( ) 200 (five steps!)

19 A Review/Overview of Scheme What if we passed in nil instead? ((lambda (x y) (if x (+ y y) 0) nil (* 10 10)) Applicative: ((lambda (x y) (if x (+ y y)) nil 100) (if nil ( ) 0) 0 (three steps!) Normal (if nil (+ (* 10 10) (* 10 10)) 0) 0 (two steps) Both applicative and normal order can do extra work! Applicative is usually faster, and doesn't require us to pass around closures all the time. 19

20 A Review/Overview of Scheme 20 Strict vs Non-Strict: We can have code that has an undefined result. (f) is undefined for (define f (lambda () (f))) - infinite recursion (define f (lambda () (/ 1 0)) - divide by 0. A pure function is: strict if it is undefined when any of its arguments is undefined, non-strict if it is defined even when one of its arguments is undefined. Applicative order == strict. Normal order == can be non-strict. ML, Scheme (except for macros) == strict. Haskell == nonstrict.

21 A Review/Overview of Scheme 21 Lazy Evaluation: Combines non-strictness of normal-order evaluation with the speed of applicative order. Idea: - Pass in closure. - Evaluate it once. - Store result in memo. - Next time, just return memo. Example 1: ((lambda (a b) (if a (+ b b) nil)) t (expensivefunc)) (if t (+ (expensivefunc) (expensivefunc)) nil) (+ (expensivefunc) (expensivefunc)) (+ 42 (expensivefunc)) <- takes a long time. ( ) <- very fast. 84 Example2: ((lambda (a b) (if a (+ b b) nil)) nil (expensivefunc)) (if nil (+ (expensivefunc) (expensivefunc)) nil) nil never evaluated expensivefunc! win!

22 22 Currying Named for Haskell Curry Example: let a function add that take two arguments: int add(int a, int b) { return a + b; } with the type signature: (int, int) -> int, i.e., takes 2 integers, returns an int. We can curry this, to create a function with signature: int -> (int -> int) using the curried version: f = add(1) print f(2) -> prints out 3. Really useful in practice, even in non-fp languages. Some languages use currying as their main function-calling semantics (ML): fun add a b : int = a + b; ML's calling conventions make this easier to work with: add 1 add 1 2 (There's no need to delimit arguments.)

23 Pattern Matching It's common for FP languages to include pattern matching operations: matching on value, matching on type, matching on structure (useful for lists). ML example: fun sum_even l = case l of nil => 0 b :: nil => 0 a :: b :: t => h + sum_even t; 23

24 Memoization Caching Results of Previous Computations (LISP): (defun fib (n) (if (<= n 1) 1 (+ (fib (- n 1)) (fib (- n 2))))) (setf memo-fib (memo #'fib)) (funcall memo-fib 3) => 3 (fib 5) => 8 (fib 6) => 13) 24

25 LISP (+ 2 2) => 4 ( ) => 55 (- ( ) ( )) => 4444) (append '(Pat Kim) '(Robin Sandy)) => (PAT KIM ROBIN SANDY) '(pat Kim) => (PAT KIM)) 25

26 LISP (setf p '(John Q Public)) (first p)) (rest p)) (second p)) (third p)) (fourth p)) (length p)) (setf names '((John Q Public) (Malcolm X) (Miss Scarlet)) (first (first names)) => JOHN) (apply #'+ '( )) => 10 26

27 LISP 27 (remove 1 '( )) => ( ) Destructive lists: (setq x '(a b c)) (setq y '(1 2 3)) (nconc x y) => (a b c 1 2 3) x => (a b c 1 2 3) y => (1 2 3)

28 A Bit of OCaml OCaml is a descendent of ML, and cousin to Haskell, F# O stands for objective, referencing the object orientation introduced in the 1990s Interpreter runs a read-eval-print loop like in Scheme Things typed into the interpreter are evaluated (recursively) once Parentheses are NOT function calls, but indicate tuples 28

29 A Bit of OCaml 29 Ocaml: Boolean values Numbers Chars Strings More complex types created by lists, arrays, records, objects, etc. (+ - * /) for ints, (+. -. *. /.) for floats let keyword for creating new names let average = fun x y -> (x +. y) /. 2.;;

30 A Bit of OCaml Ocaml: Variant Types type 'a tree = Empty Node of 'a * 'a tree * 'a tree;; Pattern matching let atomic_number (s, n, w) = n;; let mercury = ("Hg", 80, );; atomic_number mercury;; 80 30

31 A Bit of OCaml OCaml: Different assignments for references := and array elements <- let insertion_sort a = for i = 1 to Array.length a - 1 do let t = a.(i) in let j = ref i in while!j > 0 && t < a.(!j - 1) do done; done;; a.(!j) <- a.(!j - 1); j :=!j - 1 a.(!j) <- t 31

32 A Bit of OCaml OCaml: Different assignments for references := and array elements <- let insertion_sort a = for i = 1 to Array.length a - 1 do let t = a.(i) in let j = ref i in while!j > 0 && t < a.(!j - 1) do done; done;; a.(!j) <- a.(!j - 1); j :=!j - 1 a.(!j) <- t 32

33 Functional Programming in Perspective Advantages of functional languages lack of side effects makes programs easier to understand lack of explicit evaluation order (in some languages) offers possibility of parallel evaluation (e.g. MultiLisp) lack of side effects and explicit evaluation order simplifies some things for a compiler programs are often surprisingly short language can be extremely small and yet powerful 33

34 Functional Programming in Perspective Problems difficult (but not impossible!) to implement efficiently on von Neumann machines lots of copying of data through parameters frequent procedure calls heavy space use for recursion requires garbage collection requires a different mode of thinking by the programmer difficult to integrate I/O into purely functional model 34

35 Functional Programming in Perspective Other languages are embracing and integrating the concepts of Functional Programming: Java 8 - Higher Order Functions: Methods: Math#add(int, int) static Math#add(int)(int) dynamic method If an interface contains one method, then a method with the right signature can be an instance that implements that interface: button.addactionlistener(this#onbutton(actionevent)) Also adds inner methods, anonymous inner methods. 35

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

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

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

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

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

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

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

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

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

Functional Programming Björn B. Brandenburg The University of North Carolina at Chapel Hill Based in part on slides and notes by S. Olivier, A. Block, N. Fisher, F. Hernandez-Campos, and D. Stotts. Brief

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

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

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

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

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

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

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

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

### UMBC CMSC 331 Final Exam

UMBC CMSC 331 Final Exam Name: UMBC Username: You have two hours to complete this closed book exam. We reserve the right to assign partial credit, and to deduct points for answers that are needlessly wordy

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

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

Harvard School of Engineering and Applied Sciences CS 152: Programming Languages Tuesday, February 19, 2013 The lambda calculus (or λ-calculus) was introduced by Alonzo Church and Stephen Cole Kleene in

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

### CMSC330. Objects, Functional Programming, and lambda calculus

CMSC330 Objects, Functional Programming, and lambda calculus 1 OOP vs. FP Object-oriented programming (OOP) Computation as interactions between objects Objects encapsulate mutable data (state) Accessed

### Functional Programming and λ Calculus. Amey Karkare Dept of CSE, IIT Kanpur

Functional Programming and λ Calculus Amey Karkare Dept of CSE, IIT Kanpur 0 Software Development Challenges Growing size and complexity of modern computer programs Complicated architectures Massively

### Programming Systems in Artificial Intelligence Functional Programming

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 Overview

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

### Architecture of LISP Machines. Kshitij Sudan March 6, 2008

Architecture of LISP Machines Kshitij Sudan March 6, 2008 A Short History Lesson Alonzo Church and Stephen Kleene (1930) λ Calculus ( to cleanly define "computable functions" ) John McCarthy (late 60 s)

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

10 Functional Languages Previous chapters of this text have focused largely on imperative programming languages. In the current chapter and the next we emphasize functional and logic languages instead.

### 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 415 Midterm Exam Spring 2002

CS 415 Midterm Exam Spring 2002 Name KEY Email Address Student ID # Pledge: This exam is closed note, closed book. Good Luck! Score Fortran Algol 60 Compilation Names, Bindings, Scope Functional Programming

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

### Symbolic Programming. Dr. Zoran Duric () Symbolic Programming 1/ 89 August 28, / 89

Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic expressions. Symbolic manipulation: you do it all the

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

### A Small Interpreted Language

A Small Interpreted Language What would you need to build a small computing language based on mathematical principles? The language should be simple, Turing equivalent (i.e.: it can compute anything that

### Concepts of Programming Languages

Concepts of Programming Languages Lecture 15 - Functional Programming Patrick Donnelly Montana State University Spring 2014 Patrick Donnelly (Montana State University) Concepts of Programming Languages

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

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

### Introduction to Scheme

How do you describe them Introduction to Scheme Gul Agha CS 421 Fall 2006 A language is described by specifying its syntax and semantics Syntax: The rules for writing programs. We will use Context Free

### A Brief Introduction to Common Lisp

A Brief Introduction to Common Lisp David Gu Schloer Consulting Group david_guru@gty.org.in A Brief History Originally specified in 1958, Lisp is the second-oldest highlevel programming language in widespread

### Lambda Calculus and Lambda notation in Lisp II. Based on Prof. Gotshalks notes on Lambda Calculus and Chapter 9 in Wilensky.

λ Calculus Basis Lambda Calculus and Lambda notation in Lisp II Based on Prof. Gotshalks notes on Lambda Calculus and Chapter 9 in Wilensky Mathematical theory for anonymous functions» functions that have

### CS 6110 S14 Lecture 1 Introduction 24 January 2014

CS 6110 S14 Lecture 1 Introduction 24 January 2014 1 Introduction What is a program? Is it just something that tells the computer what to do? Yes, but there is much more to it than that. The basic expressions

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

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

### CS 314 Principles of Programming Languages

CS 314 Principles of Programming Languages Lecture 15: Review and Functional Programming Zheng (Eddy) Zhang Rutgers University March 19, 2018 Class Information Midterm exam forum open in Sakai. HW4 and

### CMSC 331 Final Exam Section 0201 December 18, 2000

CMSC 331 Final Exam Section 0201 December 18, 2000 Name: Student ID#: You will have two hours to complete this closed book exam. We reserve the right to assign partial credit, and to deduct points for

### Introduction to LISP. York University Department of Computer Science and Engineering. York University- CSE V.

Introduction to LISP York University Department of Computer Science and Engineering York University- CSE 3401- V. Movahedi 11_LISP 1 Introduction to LISP Evaluation and arguments S- expressions Lists Numbers

### CMSC 330: Organization of Programming Languages

CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 1 Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Use currying

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

### INF4820: Algorithms for Artificial Intelligence and Natural Language Processing. Common Lisp Fundamentals

INF4820: Algorithms for Artificial Intelligence and Natural Language Processing Common Lisp Fundamentals Stephan Oepen & Murhaf Fares Language Technology Group (LTG) August 30, 2017 Last Week: What is

### Modern Programming Languages. Lecture LISP Programming Language An Introduction

Modern Programming Languages Lecture 18-21 LISP Programming Language An Introduction 72 Functional Programming Paradigm and LISP Functional programming is a style of programming that emphasizes the evaluation

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

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

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

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

Fall 2018 Introduction to OCaml Yu Zhang Course web site: http://staff.ustc.edu.cn/~yuzhang/tpl References Learn X in Y Minutes Ocaml Real World OCaml Cornell CS 3110 Spring 2018 Data Structures and Functional

### CSE 413 Languages & Implementation. Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341)

CSE 413 Languages & Implementation Hal Perkins Winter 2019 Structs, Implementing Languages (credits: Dan Grossman, CSE 341) 1 Goals Representing programs as data Racket structs as a better way to represent

### 301AA - Advanced Programming [AP-2017]

301AA - Advanced Programming [AP-2017] Lecturer: Andrea Corradini andrea@di.unipi.it Tutor: Lillo GalleBa galleba@di.unipi.it Department of Computer Science, Pisa Academic Year 2017/18 AP-2017-15: Func'onal

### CMSC 330: Organization of Programming Languages. Lambda Calculus

CMSC 330: Organization of Programming Languages Lambda Calculus 1 Turing Completeness Turing machines are the most powerful description of computation possible They define the Turing-computable functions

### CS 242. Fundamentals. Reading: See last slide

CS 242 Fundamentals Reading: See last slide Syntax and Semantics of Programs Syntax The symbols used to write a program Semantics The actions that occur when a program is executed Programming language

### Look at the outermost list first, evaluate each of its arguments, and use the results as arguments to the outermost operator.

LISP NOTES #1 LISP Acronymed from List Processing, or from Lots of Irritating Silly Parentheses ;) It was developed by John MacCarthy and his group in late 1950s. Starting LISP screen shortcut or by command

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

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

### Racket. CSE341: Programming Languages Lecture 14 Introduction to Racket. Getting started. Racket vs. Scheme. Example.

Racket Next 2+ weeks will use the Racket language (not ML) and the DrRacket programming environment (not emacs) Installation / basic usage instructions on course website CSE34: Programming Languages Lecture

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

### (Refer Slide Time: 4:00)

Principles of Programming Languages Dr. S. Arun Kumar Department of Computer Science & Engineering Indian Institute of Technology, Delhi Lecture - 38 Meanings Let us look at abstracts namely functional

### John McCarthy IBM 704

How this course works SI 334: Principles of Programming Languages Lecture 2: Lisp Instructor: an arowy Lots of new languages Not enough class time to cover all features (e.g., Java over the course of 34-36:

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

### Introduction to ML. Mooly Sagiv. Cornell CS 3110 Data Structures and Functional Programming

Introduction to ML Mooly Sagiv Cornell CS 3110 Data Structures and Functional Programming Typed Lambda Calculus Chapter 9 Benjamin Pierce Types and Programming Languages Call-by-value Operational Semantics

### Principles of Programming Languages

Principles of Programming Languages h"p://www.di.unipi.it/~andrea/dida2ca/plp-14/ Prof. Andrea Corradini Department of Computer Science, Pisa Func;onal programming languages Introduc;on to Hakell Lesson

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

### Functional Programming with Common Lisp

Functional Programming with Common Lisp Kamen Tomov ktomov@hotmail.com July 03, 2015 Table of Contents What is This About? Functional Programming Specifics Is Lisp a Functional Language? Lisp Says Hi Functional

### CIS4/681 { Articial Intelligence 2 > (insert-sort '( )) ( ) 2 More Complicated Recursion So far everything we have dened requires

1 A couple of Functions 1 Let's take another example of a simple lisp function { one that does insertion sort. Let us assume that this sort function takes as input a list of numbers and sorts them in ascending

### FUNKCIONÁLNÍ A LOGICKÉ PROGRAMOVÁNÍ 2. ÚVOD DO LISPU: ATOMY, SEZNAMY, FUNKCE,

FUNKCIONÁLNÍ A LOGICKÉ PROGRAMOVÁNÍ 2. ÚVOD DO LISPU: ATOMY, SEZNAMY, FUNKCE, 2011 Jan Janoušek MI-FLP Evropský sociální fond Praha & EU: Investujeme do vaší budoucnosti L I S P - Introduction L I S P

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

### An Introduction to Scheme

An Introduction to Scheme Stéphane Ducasse stephane.ducasse@inria.fr http://stephane.ducasse.free.fr/ Stéphane Ducasse 1 Scheme Minimal Statically scoped Functional Imperative Stack manipulation Specification

### CSCI B522 Lecture 11 Naming and Scope 8 Oct, 2009

CSCI B522 Lecture 11 Naming and Scope 8 Oct, 2009 Lecture notes for CS 6110 (Spring 09) taught by Andrew Myers at Cornell; edited by Amal Ahmed, Fall 09. 1 Static vs. dynamic scoping The scope of a variable

### Names, Bindings, Scopes

Names, Bindings, Scopes Variables In imperative l Language: abstractions of von Neumann machine Variables: abstraction of memory cell or cells Sometimes close to machine (e.g., integers), sometimes not

### Lambda Calculus LC-1

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

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

### One of a number of approaches to a mathematical challenge at the time (1930): Constructibility

λ Calculus Church s λ Calculus: Brief History One of a number of approaches to a mathematical challenge at the time (1930): Constructibility (What does it mean for an object, e.g. a natural number, to

### Test 1 Summer 2014 Multiple Choice. Write your answer to the LEFT of each problem. 5 points each 1. Preprocessor macros are associated with: A. C B.

CSE 3302 Test 1 1. Preprocessor macros are associated with: A. C B. Java C. JavaScript D. Pascal 2. (define x (lambda (y z) (+ y z))) is an example of: A. Applying an anonymous function B. Defining a function

### Programming Language Features. CMSC 330: Organization of Programming Languages. Turing Completeness. Turing Machine.

CMSC 330: Organization of Programming Languages Lambda Calculus Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Ø Use currying or tuples

### CMSC 330: Organization of Programming Languages

CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 1 Programming Language Features Many features exist simply for convenience Multi-argument functions foo ( a, b, c ) Ø Use currying

### Robot Programming with Lisp

4. Functional Programming: Higher-order Functions, Map/Reduce, Lexical Scope Institute for Artificial University of Bremen 9 of November, 2017 Functional Programming Pure functional programming concepts

### Streams, Delayed Evaluation and a Normal Order Interpreter. CS 550 Programming Languages Jeremy Johnson

Streams, Delayed Evaluation and a Normal Order Interpreter CS 550 Programming Languages Jeremy Johnson 1 Theme This lecture discusses the stream model of computation and an efficient method of implementation

### CS 360 Programming Languages Interpreters

CS 360 Programming Languages Interpreters Implementing PLs Most of the course is learning fundamental concepts for using and understanding PLs. Syntax vs. semantics vs. idioms. Powerful constructs like

### CMSC 330: Organization of Programming Languages

CMSC 330: Organization of Programming Languages Lambda Calculus CMSC 330 Summer 2017 1 100 years ago Albert Einstein proposed special theory of relativity in 1905 In the paper On the Electrodynamics of

### Polymorphism and Type Inference

Polymorphism and Type Inference Volker Stolz stolz@ifi.uio.no Department of Informatics University of Oslo Initially by Gerardo Schneider. Based on John C. Mitchell s slides (Stanford U.) Compile-time

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

### CMSC 330: Organization of Programming Languages. Lambda Calculus

CMSC 330: Organization of Programming Languages Lambda Calculus 1 100 years ago Albert Einstein proposed special theory of relativity in 1905 In the paper On the Electrodynamics of Moving Bodies 2 Prioritätsstreit,

### Lecture 13 CIS 341: COMPILERS

Lecture 13 CIS 341: COMPILERS Announcements HW4: OAT v. 1.0 Parsing & basic code generation Due: March 28 th START EARLY! Midterm Exam Grades Available on Gradescope Zdancewic CIS 341: Compilers 2 Midterm

### Topic III. LISP : functions, recursion, and lists References: Chapter 3 of Concepts in programming languages by J. C. Mitchell. CUP, 2003.

Topic III LISP : functions, recursion, and lists References: Chapter 3 of Concepts in programming languages by J. C. Mitchell. CUP, 2003. Chapters 5( 4.5) and 13( 1) of Programming languages: Design and

Haskell Review COMP360 Some people talk in their sleep. Lecturers talk while other people sleep Albert Camus Remaining Schedule Friday, April 7 Haskell Monday, April 10 Logic Programming read chapter 12

### Closures. Mooly Sagiv. Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming

Closures Mooly Sagiv Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming t ::= x x. t t t Call-by-value big-step Operational Semantics terms variable v ::= values abstraction x.