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 to Scheme COMMON LISP ML & Haskell – not covered Closures – Added Topic Applications of Functional Languages Comparison of Functional and Imperative Languages Copyright © 2006 Addison-Wesley. All rights reserved.

Why study functional languages? Without understanding functional programming, you can’t invent MapReduce, the algorithm that makes Google so massively scalable. —Joel Spolsky, The Perils of Java Schools Copyright © 2006 Addison-Wesley. All rights reserved.

Introduction The design of the imperative languages is based directly on the von Neumann architecture Efficiency is the primary concern, rather than the suitability of the language for software development The design of the functional languages is based on mathematical functions A solid theoretical basis that is also closer to the user, but relatively unconcerned with the architecture of the machines on which programs will run Copyright © 2006 Addison-Wesley. All rights reserved.

Backus – 1978 Turing Award lecture Made a case for pure functional languages more readable, more reliable, more likely to be correct meaning of expressions are independent of their context (no side effects) Proposed pure functional language FP Copyright © 2006 Addison-Wesley. All rights reserved.

Fundamentals of Functional Programming Languages The objective of the design of a FPL is to mimic mathematical functions to the greatest extent possible The basic process of computation is fundamentally different in a FPL than in an imperative language In an imperative language, operations are done and the results are stored in variables for later use Management of variables is a constant concern and source of complexity for imperative programming In an FPL, variables are not necessary*, as is the case in mathematics * Scheme not pure – we will use some variables, but minimal compared to imperative Copyright © 2006 Addison-Wesley. All rights reserved.

Referential Transparency In an FPL, the evaluation of a function always produces the same result given the same parameters Means the expression can be replaced with its result without changing the meaning of the program (true because no side effects; must be determinate) Semantics of purely functional languages are therefore simpler than imperative languages Copyright © 2006 Addison-Wesley. All rights reserved.

Mathematical Functions A mathematical function is a mapping of members of one set, called the domain set, to another set, called the range set Mapping is described by an expression or in some cases a table Evaluation order is controlled by recursion and conditional expressions rather than by sequencing and iteration A math function defines a value rather than a sequence of operations on values in memory. No variables, no side effects. Copyright © 2006 Addison-Wesley. All rights reserved.

Lambda Expression A lambda expression specifies the parameter(s) and the mapping of a function in the following form (x) x * x * x for the function cube (x) = x * x * x Lambda expressions describe nameless functions Copyright © 2006 Addison-Wesley. All rights reserved.

Lambda Expressions Lambda expressions are applied to parameter(s) by placing the parameter(s) after the expression e.g., ((x) x * x * x)(2) which evaluates to 8 Lambda expression may have more than one parameter Copyright © 2006 Addison-Wesley. All rights reserved.

Functional Forms A higher-order function, or functional form, is one that: takes functions as parameters or yields a function as its result, or both Example outside programming: derivative in calculus Great for AI! Copyright © 2006 Addison-Wesley. All rights reserved.

Function Composition A functional form that takes two functions as parameters and yields a function whose value is the first actual parameter function applied to the application of the second Form: h  f ° g which means h (x)  f ( g ( x)) Example: f (x)  x + 2 and g (x)  3 * x, h  f ° g yields (3 * x)+ 2 Copyright © 2006 Addison-Wesley. All rights reserved.

Apply-to-all A functional form that takes a single function as a parameter and yields a list of values obtained by applying the given function to each element of a list of parameters Form:  For h (x)  x * x ( h, (2, 3, 4)) yields (4, 9, 16) Copyright © 2006 Addison-Wesley. All rights reserved.

LISP Data Types and Structures Originally, LISP was a typeless language Data object types: originally only atoms and lists Atoms are either symbols (e.g., ‘count) or numbers (e.g., 1, 2.5) List form: parenthesized collections of sublists and/or atoms ‘(A B (C D) E) ‘(1 2 5) Notice single quote, so list is not evaluated Notice no commas: not (1, 2, 5) Copyright © 2006 Addison-Wesley. All rights reserved.

LISP Lists LISP lists are stored internally as single-linked lists (A B C D) A B C D (A (B C) D (E (F G)) A D B C E F G Copyright © 2006 Addison-Wesley. All rights reserved.

LISP Interpretation Lambda notation is used to specify functions and function definitions. Function applications and data have the same form. If the list (A B C) is interpreted as data it is a simple list of three atoms, A, B, and C If it is interpreted as a function application, it means that the function named A is applied to the two parameters, B and C Functions are first-class entities They can be the values of expressions and elements of lists They can be assigned to variables and passed as parameters Cool… very useful for AI! Copyright © 2006 Addison-Wesley. All rights reserved.

Intro to Scheme We’ll use DrScheme (modern LISP) Language Pack: Swindle Function definitions go here Interpreter – try it! Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme Interpreter Interpreter is read-evaluate-write infinite loop Expressions evaluated by EVAL function Parameters are evaluated, in no particular order (literals EVAL to themselves) The values of the parameters are substituted into the function body The function body is evaluated The value of the last expression in the body is the value of the function (cube (+ 1 2)) Parameter (+ 1 2) is evaluated, passed to cube. Result (9) is returned & displayed Copyright © 2006 Addison-Wesley. All rights reserved.

Primitive Functions REMEMBER THE ( ) around function calls! Learn to read error messages, they will tell you what the evaluator was attempting when the error occurred. Copyright © 2006 Addison-Wesley. All rights reserved.

Function Definition: LAMBDA A Scheme program is collection of function definitions Pure form: Lambda Expressions Form is based on  notation e.g., (lambda (x) (* x x) x is called a bound variable Lambda expressions can be applied e.g., ((lambda (x) (* x x)) 7) Copyright © 2006 Addison-Wesley. All rights reserved.

Special Form Function: DEFINE A Function for Constructing Functions DEFINE - two forms: To bind a symbol to an expression (a constant) e.g., (define pi 3.141593) Example use: (* pi 5 5) To bind names to lambda expressions e.g., (define (square x) (* x x)) Example use: (square 5) Names are case-sensitive, include letters, digits and special characters Copyright © 2006 Addison-Wesley. All rights reserved.

Defining values & functions Must press Run (like compiler, not execution) Type definitions in upper window System loudly reminds you to press Run! Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme Run (compile) – an Error indicates edited here’s the syntax error Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme Run – still an error! not very informative  Remember: we call functions (fn-name param). For example, (square 5). SO, we need a ( in front of square, with a closing ) of course! Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme – old habits die hard… No no, the call is (square 5) NOT (square (5))…. Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme – we got it right! use ctrl-UpArrow to repeat a command Copyright © 2006 Addison-Wesley. All rights reserved.

List Functions: CAR and CDR CAR takes a list parameter; returns the first element of that list FIRST is equivalent to CAR CDR takes a list parameter; returns the list after removing its first element REST = CDR must test for ‘() before doing car recursion using cdr eventually ends up with ‘() common errors: 1) treat an atom like a list or 2) forget quote Copyright © 2006 Addison-Wesley. All rights reserved.

Creating Lists cons append list Copyright © 2006 Addison-Wesley. All rights reserved.

List Functions: CONS cons has two forms: cons (atom list) cons (list list) result is a new list that includes the first parameter as its first element and the second parameter as the remainder e.g., (cons 'A '(B C)) returns (A B C) Applying CONS to two atoms results in a dotted list (cell with two atoms, no pointer), e.g., (cons 'A 'B) returns (A . B) cons creates node Copyright © 2006 Addison-Wesley. All rights reserved. A B

Cons Example (cons atom list) (cons atom atom) (cons list list) Notice (C D) is no longer a list C D A B A B C D Copyright © 2006 Addison-Wesley. All rights reserved.

List Functions: List list takes any number of parameters; returns a list with the parameters as elements Repeated for comparison Copyright © 2006 Addison-Wesley. All rights reserved.

Example Scheme Function: append append has one form: append(list list) result is a new list containing the elements of the first parameter followed by the elements of the second parameter Example: (append '((A B) C) '(D (E F))) returns ((A B) C D (E F)) Copyright © 2006 Addison-Wesley. All rights reserved.

Append Example Repeated for comparison Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme Functional Forms Composition (cdr (cdr ‘(A B C))) returns ( C ) (car (car '((A B) B C))) returns A (cdr (car '((A B C) D))) returns (B C) (cons (car '(A B))(cdr '(A B)))returns(A B) (caar x) is equivalent to (car (car x)) (cadr x) is equivalent to (car (cdr x)) (caddar x is equivalent to (car (cdr (cdr (car x)))) Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme Exercises Now you try it. Explore the Scheme environment. Do exercises 1-3 in the Scheme Exercises. Review the common errors. Feel free to read more lecture notes and work ahead. NOTE: In case you need to comment out some code, comments in Scheme are indicated by ; Copyright © 2006 Addison-Wesley. All rights reserved.

Predicate Functions: LIST? and NULL? list? takes one parameter; it returns #T if the parameter is a list; otherwise() list? returns #T for the null list ‘() null? takes one parameter; it returns #T if the parameter is the empty list; otherwise() Note that null? returns #T if the parameter is() Copyright © 2006 Addison-Wesley. All rights reserved.

Control Flow: IF Selection- the special form, IF (if predicate true_exp false_exp) Example: (if (<> count 0) (/ sum count) 0) Copyright © 2006 Addison-Wesley. All rights reserved.

Output Functions (DISPLAY expression) (NEWLINE) Notice statements performed in sequence Copyright © 2006 Addison-Wesley. All rights reserved.

If and recursion empty list is base case compound else closes (begin call with remainder of list recursive call Copyright © 2006 Addison-Wesley. All rights reserved.

Control Flow: COND Multiple Selection - the special form, COND General form: (COND (predicate_1 expr {expr}) (predicate_2 expr {expr}) ... (predicate_n expr {expr}) (ELSE expr {expr})) Returns the value of the last expr in the first pair whose predicate evaluates to true. Based on guarded expressions (chapter 9) Predicate can be compound (using and, or) Copyright © 2006 Addison-Wesley. All rights reserved.

COND example Notice () around entire clause Notice () around close cond, Could have used else here close define Copyright © 2006 Addison-Wesley. All rights reserved.

Recursion – two ways to build list Copyright © 2006 Addison-Wesley. All rights reserved.

Numeric Predicate Functions #t (or non-null list) is true #f or () is false =, <>, >, <, >=, <= even?, odd?, zero?, negative? Copyright © 2006 Addison-Wesley. All rights reserved.

List Functions: Quote QUOTE - takes one parameter; returns the parameter without evaluation QUOTE is required because the Scheme interpreter, EVAL, always evaluates parameters before applying the function. QUOTE is used to avoid parameter evaluation when it is not appropriate QUOTE can be abbreviated with the apostrophe prefix operator Copyright © 2006 Addison-Wesley. All rights reserved.

Example Scheme Function: member member takes an atom and a simple list; returns a sublist containing the atom if it is in the list; #f otherwise Copyright © 2006 Addison-Wesley. All rights reserved.

Calling the Scheme eval function It is possible to call eval directly eval takes a list and evaluates it. The first item in the list is typically a function. (eval '(+ 3 4)) => 7 (eval '(square 6)) => 36 Copyright © 2006 Addison-Wesley. All rights reserved.

Functions That Build Code It is possible in Scheme to define a function that builds Scheme code and requests its interpretation This is possible because the interpreter is a user-available function, eval + quoted to prevent evaluation cons inserts + into list Copyright © 2006 Addison-Wesley. All rights reserved.

Function to applies a function Map – applies (maps) a function (map list? ‘(a (b c) d) => (#f #t #f) (define switchView (lambda (person) (cond ((equal? person 'i) 'you) ((equal? person 'me) 'you) ((equal? person 'you) 'me) ((equal? person 'your) 'my) ((equal? person 'yours) 'mine) ((equal? person 'am) 'are) (#t person) ))) (map switchView ‘(i can help you)) => (you can help me) Copyright © 2006 Addison-Wesley. All rights reserved.

Apply (apply FN ARG-LIST) Returns the result of applying FN to the list of arguments Assume have function: (define (isVerb word) (member word '(go have try eat take))) Can use with apply: (apply isVerb ‘(eat)) => ‘(eat take) (apply isVerb ‘(jump)) => #f Copyright © 2006 Addison-Wesley. All rights reserved.

Apply Errors Copyright © 2006 Addison-Wesley. All rights reserved.

Example Scheme Function: LET General form: (let ( (name_1 expression_1) (name_2 expression_2) ... (name_n expression_n)) body ) Evaluate all expressions, then bind the values to the names; evaluate the body. Only local. Often used to factor out common subexpressions Copyright © 2006 Addison-Wesley. All rights reserved.

LET Example (define (quadratic_roots a b c) (let ( (root_part_over_2a (/ (sqrt (- (* b b) (* 4 a c)))(* 2 a))) (minus_b_over_2a (/ (- 0 b) (* 2 a)))) (begin (display (+ minus_b_over_2a root_part_over_2a)) (newline) (display (- minus_b_over_2a root_part_over_2a)) ) Copyright © 2006 Addison-Wesley. All rights reserved.

Let* Similar to let Evaluates the exprs one by one, creating a location for each id as soon as the value is available. (let* ((x 1)    (y (+ x 1))) (list y x)) => ‘(2 1) Copyright © 2006 Addison-Wesley. All rights reserved.

Exercises Do Exercises 4-12 Do converter exercise – to submit, individual Copyright © 2006 Addison-Wesley. All rights reserved.

Predicate Function: eq? eq? takes two symbolic parameters; it returns #t if both parameters are atoms and the two are the same e.g., (eq? 'A 'A) yields #t (eq? 'A 'B) yields #f Note that if eq? is called with list parameters, the result is not reliable Also eq? does not work for numeric atoms, should use = [appears to work???] eqv? works on both symbols and numbers we’ll create function in two slides Copyright © 2006 Addison-Wesley. All rights reserved.

Our own list_member (for practice) (define (list_member atm lis) (cond ((null? lis) #f) ((eq? atm (car lis)) #t) (else (list_member atm (cdr lis))) ) State recursively: an element is a member of the list if: - the element matches the first item in the list OR - the element is a member of the rest of the list How would you modify the above to search sublists? Copyright © 2006 Addison-Wesley. All rights reserved.

Example Scheme Function: equalsimp equalsimp takes two simple lists as parameters; returns #T if the two simple lists are equal; () otherwise. Won’t handle list such as ‘(a (b c)) (define (equalsimp lis1 lis2) (cond ; if lis1 is null, #t is lis2 is null ((null? lis1) (null? lis2)) ; if lis2 is null, lis1 is not null, so ‘() ((null? lis2) '()) ((eq? (car lis1) (car lis2)) (equalsimp(cdr lis1)(cdr lis2))) (else '()) )) State recursively: two lists are equal if: - the first elements of each list match AND - the remaining lists (minus first elements) are equal) Copyright © 2006 Addison-Wesley. All rights reserved.

Example Scheme Function: equal equal takes two general lists as parameters; returns #T if the two lists are equal; ()otherwise (define (equal lis1 lis2) (cond ; if lis1 not a list, checking items in sublist ((not (list? lis1))(eq? lis1 lis2)) ; lis1 is a list but lis2 is not ((not (list? lis2)) '()) ; rest of code is like equal ((null? lis1) (null? lis2)) ((null? lis2) '()) ((equal (car lis1) (car lis2)) (equal (cdr lis1) (cdr lis2))) (else '()) )) This one can handle ‘(a (b c)) – see trace Copyright © 2006 Addison-Wesley. All rights reserved.

Equal Example Copyright © 2006 Addison-Wesley. All rights reserved.

Equal Trace (a (b c)) (a (b c)) lis1: (a (b c)) lis2: (a (b c)) lis1: a lis2: a lis1 is not a list, checking one item, returning #t cars are equal, check cdrs lis1: ((b c)) lis2: ((b c)) lis1: (b c) lis2: (b c) lis1: b lis2: b lis1: (c) lis2: (c) lis1: c lis2: c lis1: () lis2: () lis1 is null, return null? lis2 #t Copyright © 2006 Addison-Wesley. All rights reserved.

Equal Trace #2 (a (b c)) (a (d c)) lis1: (a (b c)) lis2: (a (d c)) lis1: a lis2: a lis1 is not a list, checking one item, returning #t cars are equal, check cdrs lis1: ((b c)) lis2: ((d c)) lis1: (b c) lis2: (d c) lis1: b lis2: d lis1 is not a list, checking one item, returning #f #f Copyright © 2006 Addison-Wesley. All rights reserved.

More Scheme Errors Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme errors continued Extra parenthesis, this is the action: (display result) (evenSquareErr2…) so scheme doesn’t know what to do with: ((display result)(evenSquareErr2…) Don’t try to use ( .. ) to indicate a block!! Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme errors continued… You would expect this to be a syntax error or something! But it just “falls through” when it hits the else condition. Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme debugging tip watch recursive calls see which conditions matched Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme Debugging Press Debug current step Copyright © 2006 Addison-Wesley. All rights reserved.

Scheme Exercises Continue with all exercises Copyright © 2006 Addison-Wesley. All rights reserved.

Closures From Wikipedia: a closure is a function that is evaluated in an environment containing one or more bound variables. When called, the function can access these variables. Can also be expressed as: a closure is a function that captures the lexical environment in which it was created. Constructs such as objects in other languages can also be modeled with closures (e.g., instance variables equivalent to bound variables) Copyright © 2006 Addison-Wesley. All rights reserved.

Closures, continued A closure can be used to associate a function with a set of "private" variables, which persist over several invocations of the function. The scope of the variable encompasses only the closed-over function, so it cannot be accessed from other program code. However, the variable is of indefinite extent, so a value established in one invocation remains available in the next. The concept of closures was developed in the 60’s and was first fully implemented as a language feature in the programming language Scheme. Since then, many languages have been designed to support closures. similar to static Copyright © 2006 Addison-Wesley. All rights reserved.

Closures and first-class values Closures typically appear in languages in which functions are first-class values - in other words, such languages allow functions to be passed as arguments, returned from function calls, bound to variable names, etc., just like simpler types such as strings and integers ; Copyright © 2006 Addison-Wesley. All rights reserved.

Closure in Scheme Return a list of all books with at least ; THRESHOLD copies sold. (define (best-selling-books threshold) (let ((book-list ‘'(((Gone With the Wind) 1000) ((Freakonomics) 1500) ((Cryptonomicon) 500)))) (filter (lambda (book) (>= (book-sales book) threshold)) book-list)) passed to closure for lambda code & threshold created book-list in lexical environment Copyright © 2006 Addison-Wesley. All rights reserved.

Closure in another language ECMAScript – uses function keyword instead of lambda, creates closure with Array.filter // Return a list of all books with at least // THRESHOLD copies sold. function bestSellingBooks(threshold) { return bookList.filter( function(book) return book.sales >= threshold; } ); filter is higher-order function - takes a function as a parameter Copyright © 2006 Addison-Wesley. All rights reserved.

Another closure in JavaScript Nameless function, inherits environment in which it is defined. In this case environment includes xhr object and document object. xhr.onreadystatechange = function() { if (xhr.readyState == 4) { var result = xhr.responseText; var place = result.split(‘,’_; document.getElementById(“city”).value = place[0]; document.getElementById(“state”).value = place[1]; } xhr object part of lexical environment Copyright © 2006 Addison-Wesley. All rights reserved.

Closures in Ruby fold_coder = lambda { |default_value, binary_function| fold_with_acc = lambda { |acc, list| if list.empty? acc else fold_with_acc.call(binary_function.call(acc, list.first), list[1..-1]) end } lambda { |list| fold_with_acc.call(default_value, list) } } ; create closure adder = fold_coder.call(0, lambda { |a, b| a + b }) ; call it adder.call([1, 2, 3, 4, 5]) adder.call([2, 4, 6, 8, 10]) * From http://weblog.raganwald.com/2007/01/closures-and-higher-order-functions.html Copyright © 2006 Addison-Wesley. All rights reserved.

Lexical Closure – from Wiki "A lexical closure is, first of all, an object- …with special notation... That notation specifies an anonymous piece of code that can take arguments, and is in fact an anonymous function. The anonymous function is a component of the closure object, but not the only component. The other component of the object is the lexical environment: a snapshot of all of the current bindings of all of the local variables which are visible at that point." The bindings of the variables are the values of the variables, not the addresses that the names point to. Copyright © 2006 Addison-Wesley. All rights reserved. if addresses, would be just like globals

More Terminology Within some scope a free variable is a variable that is not bound within that scope, i.e. that within some scope there is no declaration of that variable. The name "Closure" comes from the terminology that the function-procedure "closes-over" its environment, capturing the current bindings of its free variables. Copyright © 2006 Addison-Wesley. All rights reserved.

Example: Callback with Closures ;; In the library: (define (register-callback event-type handler-proc) ...) ;; In the application: (define (make-handler event-type user-data) (lambda () ... <code referencing event-type and user-data> ...)) (register-callback event-type (make-handler event-type ...)) library sees handler-proc as procedure with no arguments handler procedure has used closure to capture environment – event type and user data Copyright © 2006 Addison-Wesley. All rights reserved.

Closure Implementation Closures are typically implemented with a special data structure that contains a pointer to the function code, plus a representation of the function's lexical environment (e.g., the set of available variables and their values) at the time when the closure was created. A language implementation cannot easily support full closures if its run-time memory model allocates all local variables on a linear stack. In such languages, a function's local variables are deallocated when the function returns. However, a closure requires that the free variables it references survive the enclosing function's execution. Therefore those variables must be allocated so that they persist until no longer needed. This explains why typically languages that natively support closures use garbage collection. Copyright © 2006 Addison-Wesley. All rights reserved.

Closure Implementation (continued) A typical modern Scheme implementation allocates local variables that might be used by closures dynamically and stores all other local variables on the stack. Copyright © 2006 Addison-Wesley. All rights reserved.

Interesting Perspectives http://home.tiac.net/~cri/2005/closure.html http://gafter.blogspot.com/2007/01/definition- of-closures.html Copyright © 2006 Addison-Wesley. All rights reserved.

Applications of Functional Languages APL is used for throw-away programs LISP is used for artificial intelligence Knowledge representation/Expert systems Machine learning Natural language processing Modeling of speech and vision Emacs editor Scheme is used to teach introductory programming at a significant number of universities Haskell and ML in research labs Copyright © 2006 Addison-Wesley. All rights reserved.

Comparing Functional and Imperative Languages Efficient execution Complex semantics Complex syntax Concurrency is programmer designed Functional Languages: Simple semantics (like math functions, may or may not feel “natural” to programmers) Simple syntax Inefficient execution (not as bad if compiled) Programs can automatically be made concurrent Copyright © 2006 Addison-Wesley. All rights reserved.

Summary Functional programming languages use function application, conditional expressions, recursion, and functional forms to control program execution instead of imperative features such as variables and assignments LISP began as a purely functional language and later included imperative features Scheme is a relatively simple dialect of LISP that uses static scoping exclusively COMMON LISP is a large LISP-based language ML is a static-scoped and strongly typed functional language which includes type inference, exception handling, and a variety of data structures and abstract data types Haskell is a lazy functional language supporting infinite lists and set comprehension. Purely functional languages have advantages over imperative alternatives, but their lower efficiency on existing machine architectures has prevented them from enjoying widespread use Copyright © 2006 Addison-Wesley. All rights reserved.