Functional programming techniques

Save this PDF as:
 WORD  PNG  TXT  JPG

Size: px
Start display at page:

Download "Functional programming techniques"

Transcription

1 Functional programming techniques o Currying o Continuations o Streams. Lazy evaluation Currying o Haskell B. Curry. o Second-order programming: o Functions that return other functions. o Example: A two-arguments function is transformed in a oneargument function that returns a one-argument function. (defun adder (x) #'(lambda (y) (+ x y))) (adder 2) #'(lambda (y) (+ 2 y)) (funcall (adder 2) 3) 5 (setf f (adder 2)) (funcall f 3) 5 ML programming fun adder x y = x + y adder: int int int adder 2: int int

2 Examples (defun member (x l) (when l (or (equal (first l) x) (member x (rest l))))) (defun member-c (x) #'(lambda (list) (labels ((look (l) (when l (or (equal (first l) x) (look (rest l)))))) (look list)))) (defun new-member (a l) (funcall (member-c a) l)) Examples (defun map-c (fn) #'(lambda (args) (labels ((aplica (l) (when l (cons (funcall fn (first l)) (aplica (rest l)))))) (aplica args)))) (defun new-map (fn args) (funcall (map-c fn) args))

3 Currying o Generalization: Transform a function with n = m + k parameters into a function with m parameters that returns a function with k parameters. (defun swapper (x y ls) (cond ((null ls) nil) ((equal (first ls) x) (cons y (swapper x y (rest ls)))) ((equal (first ls) y) (cons x (swapper x y (rest ls)))) (t (cons (first ls) (swapper x y (rest ls)))))) (defun swapper-c (x y) #'(lambda (ls) (labels ((look-up (ls) (cond ((null ls) nil) ((equal (first ls) x) (cons y (look-up (rest ls)))) ((equal (first ls) y) (cons x (look-up (rest ls)))) (t (cons (first ls) (look-up (rest ls))))))) (look-up ls)))) (defun swapper-nou (x y ls) (funcall (swapper-c x y) ls)) (setf pp (swapper-c a b)) (funcall pp (c a d b e)) (c b d a e)

4 Currying o Useful when one (o more) of the arguments of a function remains constant o Efficiency in recursive programming: the stack of functional calls is shorter o Lambda functions of only one argument without losing of representation power o Related to the partial evaluation theorem by Kleene (1952): o Given a computable function f of n variables f(x 1,x 2,...,x n ) and k (k<=n) values a 1,..., a k. It is possible to compute a new function f such that: f (x k+1, x k+2,..., x n ) = f(x 1,x 2,...,x n ) Currying o AI interest: to model partial functions, needed for the management of incomplete reasoning o Partial deduction (logic programming) o Specialization: (A B) C A (B C) o Knowledge-base specialization (Milord II): (A, α), (A B C, ρ) (B C, f ( α, ρ)) a b z... KB... α β ζ b z... KB'... α β ζ z... KB''... α β ζ

5 Continuations o Idea: Given a n-argument function, we add a new continuation argument. The result of the original function is given to the continuation. o (defun f (x) x) o (defun f(x,continuation) (funcall continuation x)) o Program transformation technique based on secondorder functions. New programs are more efficiently represented. o Scheme o SML/NJ, Haskell o Actors model o Multiprocessing, search o Objects containing the state of the computation Example I (no recursive) Without continuations (defun length2 (x) (list x (length x))) (defun print-length2 (list) (format t The length is: ~A (length2 list))) With continuations (defun length2-c (x -c-) (funcall -c- (list x (length x)))) (defun print-length2 (list) (length2-c list # (lambda (val) (format t The length is: ~A (length2 val)))))

6 Continuations (recursive functions) o Program transformation technique based on secondorder functions. New programs are more efficiently represented. o Idea: Given a one-argument function, we find a new two-argument tail-recursive function. The first argument is of the same type that the original one and, the second is a function called continuation. o It is easy to define a new tail-recursive function. o Problem: second-order function representation is expensive. o Benefits when continuations can be represented as simple data structures, for instance, lists. Continuations (recursive functions) o Suppose the following function: f(x) = if p then q else E where x can appear in p, q and E o f appears only one time in E, applied over a sub expression of x, f(s(x)) o In the non trivial case a, where p[a/x] is false, the computation returns r = f(s(a)), γ = λw.ew where Ew = E[f(s(x))/w] o The function γ is applied over r, γ(r)

7 Continuations o Equivalent function for f: f(x) = f-tr(x,id) f-tr(x,γ) = γ(f(x)) = if p then γ(q) else f-tr(s(x),λw.γew) [Field i Harrison, 1988] o The function γ is called a continuation, the pending computation to perform after the calculation of the recursive call. Example II (recursive) o Optimization of tail-recursive calls No tail-recursive (defun fact (n) (if (= n 0) 1 (* n (fact (- n 1))))) (defun fact-c (n -c-) (if (= n 0) (funcall -c- 1) (fact-c (- n 1) # (lambda (val) (funcall -c- (* n val)))))) (defun fact (n) (fact-c n # (lambda (val) val)))

8 Memoize (defun memo (fn &key (key #'first) (test #'eql) name) "Return a memo-function of fn." (let ((table (make-hash-table :test test))) (setf (get name :memo) table) #'(lambda (&rest args) (let ((k (funcall key args))) (multiple-value-bind (val found-p) (gethash k table) (if found-p val (setf (gethash k table) (apply fn args)))))))) (defun clear-memoize (fn-name) "Clear the hash table from a memo function." (let ((table (get fn-name :memo))) (when table (clrhash table)))) (defun memoize (fn-name &key (key #'first) (test #'eql)) "Replace fn-name's global definition with a memoized version." (clear-memoize fn-name) (setf (symbol-function fn-name) (memo (symbol-function fn-name) :name fn-name :key key :test test))) Example III o Continuation in a local function Σ n x (defun sum-iter (n) (let ((sum 0)) (loop (if (= n 0) (return sum)) (setq sum (+ sum n)) (setq n (- n 1))))) (defun sum-clean (n) (labels ((sum-loop (n sum) (if (= n 0) sum (sum-loop (- n 1) (+ sum n))))) (sum-loop n 0))) (defun sum-cont (n -c-) (labels ((sum-loop (n sum) (if (= n 0) (funcall -c- sum) (sum-loop (- n 1) (+ sum n))))) (sum-loop n 0)))

9 Coroutines (make-array '(4 2 3) :initial-contents '(((a b c) (1 2 3)) ((d e f) (3 1 2)) ((g h i) (2 3 1)) ((j k l) (0 0 0)))) array-dimension aref (defun write-matrix (M) (let ((heigth (array-dimension M 0)) (width (array-dimension M 1))) (labels ((write-loop (i j corou) (cond ((= i heigth) nil) ((= j width) (write-loop (1+ i) 0 corou)) (t (funcall corou #'(lambda (item corou) (setf (aref M i j) item) (write-loop i (1+ j) corou))))))) (write-loop 0 0 corou))))) (defun read-matrix (M) (let ((heigth (array-dimension M 0)) (width (array-dimension M 1))) (labels ((read-loop (i j corou) (cond ((= i heigth) nil) ((= j width) (read-loop (1+ i) 0 corou)) (t (funcall corou (aref M i j) (read-loop i (1+ j) corou))))))) (read-loop 0 0 corou))))) (defun transfer-matrix (M1 M2) (let ((reader (read-matrix M1)) (writer (write-matrix M2))) (funcall writer reader))) Coroutines M1 = #2A((1 2 3)(4 5 6)) M2 = #2A((nil nil)(nil nil)) (funcall (write-matrix M2)(read-matrix M1)) M2 = #2A((1 2)(3 4)) (funcall (labels ((write-loop (i j corou) (cond ((= i 2) nil) ((= j 2) (write-loop (1+ i) 0 corou)) (t (funcall corou #'(lambda (item corou) (setf (aref M2 i j) item) (write-loop i (1+ j) corou))))))) (write-loop 0 0 corou))) (labels ((read-loop (i j corou) (cond ((= i 2) nil) ((= j 3) (read-loop (1+ i) 0 corou)) (t (funcall corou (aref M1 i j) (read-loop i (1+ j) corou))))))) (read-loop 0 0 corou)))) (funcall (labels ((read-loop (i j corou) (cond ((= i 2) nil) ((= j 3) (read-loop (1+ i) 0 corou)) (t (funcall corou (aref M1 i j) (read-loop i (1+ j) corou))))))) (read-loop 0 0 corou))) #'(lambda (item corou) (setf (aref M2 0 0) item) (write-loop 0 1 corou))) (funcall #'(lambda (item corou) (setf (aref M2 0 0) item) (write-loop 0 1 corou)) (aref M1 0 0) (read-loop 0 1 corou))) (setf (aref M2 0 0) (aref M1 0 0)) (write-loop 0 1 (read-loop 0 1 corou))))

10 Control Flow o Continuations are useful to define control strategies o Common Lisp uses continuations in: o BLOCK/RETURN_FROM lexical o CATCH/THROW dynamic (catch tag (...) (...)...) (if (...) (block then (setq...) (list... (return-from then...))) (...) (defun f (x) (catch 'hola (+ x 1) (+ 5 (g x)))) (throw tag (...)) (defun g (x) (if (< x 5) 567 (throw 'hola 10000))) Control Flow OnLisp: Chapter 20 o These mechanisms can be described with the function CALL-WITH-CURRENT-CONTINUATION (no Common Lisp) o Scheme (lisp dialect) o (+ 1 call/cc (lambda (cont) ( ))) 321 o (+ 1 call/cc (lambda (cont) (+ 20 (cont 300)))) 301 (defmacro block (name &rest forms) `(call-with-current-continuation #'(lambda (defmacro return-from (name &optional value) `(funcall,name,value))

11 ATN (Augmented transition network) s::= np vp to-be np pred np::= proper-noun pronoun det noun vp::= to-be np to-be pred pred::= adj pp pp::= prep np adj::= nice small blue prep::= to in on out to-be ::= is are was were det::= the proper-noun::= maria carles antoni noun::= house car table pronoun::= mine yours ours theirs Maria is nice The house is blue The table is mine Two continuations: success or failure ATN (Augmented transition network) I (defun cont-atn (s) (parse-s s (cond ((null s) success) (T (funcall return)))) 'failure))) (defun parse-s (s success failure) (parse-np s (parse-vp s success return)) (categoria? 'to-be s (parse-np s (parse-pred s sucess return)) return)) failure)))) Success Failure (defun parse-np (s success failure) (categoria? 'proper-noun s sucess (categoria? 'pronoun s sucess (categoria? 'det s (categoria? 'noun s sucess return)) failure)))))) Syntax? (cont-atn (Maria is nice)) (parse-s (Maria is nice) success1 failure1) (parse-np (Maria is nice success2 failure2) (categoria? proper-noun (Maria is nice) success2 failure3)

12 ATN II (defun parse-pred (s success failure) (categoria? 'adj s success (parse-pp s success failure)))) (defun parse-pp (s success failure) (categoria? 'prep s (parse-np s success return)) failure)) (defun categoria? (caract s success failure) (if (or (null s) (not (categoriap (first s) caract))) (funcall failure) (funcall success (rest s) failure))) (defun categoriap (mot tipus) (case tipus (adj (member mot '(nice small blue))) (prep (member mot '(to in on out))) (to-be (member mot '(is are was were))) (det (member mot '(the))) (proper-noun (member mot '(maria carles antoni))) (noun (member mot '(house car table))) (pronoun (member mot '(mine yours ours theirs))))) (categoria? proper-noun (Maria is nice) success2 failure3) (funcall success2 (is nice) failure3) (funcall # (lambda(s return) (parse-vp s success1 return)) (is nice) failure3) (parse-vp (is nice) success1 failure3) (categoria? to-be (is nice) success1 failure3) (funcall # (lambda(s return) (parse-np s success1 return)) (nice) failure3) ATN III (defun parse-np (s success failure) (categoria? 'proper-noun s success (categoria? 'pronoun s success (categoria? 'det s (categoria? 'noun s success return)) failure)))))) (defun parse-vp (s success failure) (categoria? 'to-be s (parse-np s success return)) (categoria? 'to-be s (parse-pred s success return)) failure))))

13 ATN IV (categoria? proper-noun (The house is mine) success2 failure3) (funcall failure3) (funcall (categoria? 'pronoun (The house is mine) success2 (categoria? 'det s ) (funcall (categoria? 'det (The house is mine) (categoria? 'noun s success2 return)) failure2))))))) (categoria? to-be (is mine) success1 failure3) IA interests o Pros o Search and backtracking can be simplified. o Interesting control mechanisms. Necessary to define languages. o Modular and compact programming of ATNs o No backtracking o Continuation over failure states. o Cons o Read and write this kind of code is not easy. o Problematic program debugging with anonymous functions o Inspiration

CS 842 Ben Cassell University of Waterloo

CS 842 Ben Cassell University of Waterloo CS 842 Ben Cassell University of Waterloo Recursive Descent Re-Cap Top-down parser. Works down parse tree using the formal grammar. Built from mutually recursive procedures. Typically these procedures

More information

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

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

More information

Common LISP-Introduction

Common LISP-Introduction Common LISP-Introduction 1. The primary data structure in LISP is called the s-expression (symbolic expression). There are two basic types of s-expressions: atoms and lists. 2. The LISP language is normally

More information

Announcement. Overview. LISP: A Quick Overview. Outline of Writing and Running Lisp.

Announcement. Overview. LISP: A Quick Overview. Outline of Writing and Running Lisp. Overview Announcement Announcement Lisp Basics CMUCL to be available on sun.cs. You may use GNU Common List (GCL http://www.gnu.org/software/gcl/ which is available on most Linux platforms. There is also

More information

Common Lisp. Blake McBride

Common Lisp. Blake McBride Contents Common Lisp Blake McBride (blake@mcbride.name) 1 Data Types 2 2 Numeric Hierarchy 3 3 Comments 3 4 List Operations 4 5 Evaluation and Quotes 5 6 String Operations 5 7 Predicates 6 8 Math Predicates

More information

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

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

More information

Robot Programming with Lisp

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

More information

Allegro CL Certification Program

Allegro CL Certification Program Allegro CL Certification Program Lisp Programming Series Level I Review David Margolies 1 Summary 1 A lisp session contains a large number of objects which is typically increased by user-created lisp objects

More information

A Genetic Algorithm Implementation

A Genetic Algorithm Implementation A Genetic Algorithm Implementation Roy M. Turner (rturner@maine.edu) Spring 2017 Contents 1 Introduction 3 2 Header information 3 3 Class definitions 3 3.1 Individual..........................................

More information

Lisp: Lab Information. Donald F. Ross

Lisp: Lab Information. Donald F. Ross Lisp: Lab Information Donald F. Ross General Model program source text stream What you need to write lexical analysis lexemes tokens syntax analysis is_id, is_number etc. + grammar rules + symbol table

More information

A LISP Interpreter in ML

A LISP Interpreter in ML UNIVERSITY OF OSLO Department of Informatics A LISP Interpreter in ML Mandatory Assignment 1 INF3110 September 21, 2009 Contents 1 1 Introduction The purpose of this assignment is to write an interpreter,

More information

Scheme in Scheme: The Metacircular Evaluator Eval and Apply

Scheme in Scheme: The Metacircular Evaluator Eval and Apply Scheme in Scheme: The Metacircular Evaluator Eval and Apply CS21b: Structure and Interpretation of Computer Programs Brandeis University Spring Term, 2015 The metacircular evaluator is A rendition of Scheme,

More information

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

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

More information

Organization of Programming Languages CS3200/5200N. Lecture 11

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

More information

LISP. Everything in a computer is a string of binary digits, ones and zeros, which everyone calls bits.

LISP. Everything in a computer is a string of binary digits, ones and zeros, which everyone calls bits. LISP Everything in a computer is a string of binary digits, ones and zeros, which everyone calls bits. From one perspective, sequences of bits can be interpreted as a code for ordinary decimal digits,

More information

MIDTERM EXAMINATION - CS130 - Spring 2005

MIDTERM EXAMINATION - CS130 - Spring 2005 MIDTERM EAMINATION - CS130 - Spring 2005 Your full name: Your UCSD ID number: This exam is closed book and closed notes Total number of points in this exam: 231 + 25 extra credit This exam counts for 25%

More information

Functional Programming

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

More information

UMBC CMSC 331 Final Exam Section 0101 December 17, 2002

UMBC CMSC 331 Final Exam Section 0101 December 17, 2002 0 / 0 1 / 20 UMBC CMSC 331 Final Exam Section 0101 December 17, 2002 Name: Student ID#: 2 / 25 3 / 20 4 / 25 5 / 20 6 /40 7 /40 You will have two hours to complete this closed book exam. We reserve the

More information

Normal Order (Lazy) Evaluation SICP. Applicative Order vs. Normal (Lazy) Order. Applicative vs. Normal? How can we implement lazy evaluation?

Normal Order (Lazy) Evaluation SICP. Applicative Order vs. Normal (Lazy) Order. Applicative vs. Normal? How can we implement lazy evaluation? Normal Order (Lazy) Evaluation Alternative models for computation: Normal (Lazy) Order Evaluation Memoization Streams Applicative Order: evaluate all arguments, then apply operator Normal Order: pass unevaluated

More information

(defvar *state* nil "The current state: a list of conditions.")

(defvar *state* nil The current state: a list of conditions.) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; GPS engine for blocks world ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defvar *dbg-ids* nil "Identifiers used by dbg") (defvar *state* nil "The current state: a list of conditions.")

More information

19 Machine Learning in Lisp

19 Machine Learning in Lisp 19 Machine Learning in Lisp Chapter Objectives Chapter Contents ID3 algorithm and inducing decision trees from lists of examples. A basic Lisp implementation of ID3 Demonstration on a simple credit assessment

More information

Homework. Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25

Homework. Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25 Homework Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25 Copyright c 2002 2017 UMaine Computer Science Department 1 / 33 1 COS 140: Foundations

More information

Lecture #2 Kenneth W. Flynn RPI CS

Lecture #2 Kenneth W. Flynn RPI CS Outline Programming in Lisp Lecture #2 Kenneth W. Flynn RPI CS Items from last time Recursion, briefly How to run Lisp I/O, Variables and other miscellany Lists Arrays Other data structures Jin Li lij3@rpi.edu

More information

CMSC 331 Final Exam Section 0201 December 18, 2000

CMSC 331 Final Exam Section 0201 December 18, 2000 CMSC 331 Final Exam Section 0201 December 18, 2000 Name: nswers 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

More information

A Quick Introduction to Common Lisp

A Quick Introduction to Common Lisp CSC 244/444 Notes last updated ug. 30, 2016 Quick Introduction to Common Lisp Lisp is a functional language well-suited to symbolic I, based on the λ-calculus and with list structures as a very flexible

More information

Section 10: LISP to Scheme. Evolution of Software Languages

Section 10: LISP to Scheme. Evolution of Software Languages Section Evolution of Software Languages Theo D'Hondt Bachelor of Computer Science Faculty of Sciences and Bio-Engineering Sciences Vrije Universiteit Brussel Academic Year 2015-2016 Evolution of Software

More information

Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25

Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25 Homework Reading: Chapter 17 Homework: All exercises from Chapter 17 Due: 10/27 Correction: Chapter 16 homework is due 10/25 Copyright c 2002 2017 UMaine School of Computing and Information S 1 / 33 COS

More information

Object Oriented Programming (OOP)

Object Oriented Programming (OOP) Object Oriented Programming (OOP) o New programming paradigm o Actions Objects o Objects Actions o Object-oriented = Objects + Classes + Inheritance Imperative programming o OOP (Object-Oriented Programming)

More information

CS A331 Programming Language Concepts

CS A331 Programming Language Concepts CS A331 Programming Language Concepts Lecture 10 Alternative Programming Languages (Functional LISP Declarative - PROLOG) March 24, 2014 Sam Siewert Functional PL Concepts Based on Lambda Calculus Output

More information

Department of Computer and information Science Norwegian University of Science and Technology

Department of Computer and information Science Norwegian University of Science and Technology Department of Computer and information Science Norwegian University of Science and Technology http://www.idi.ntnu.no/ A Crash Course in LISP MNFIT272 2002 Anders Kofod-Petersen anderpe@idi.ntnu.no Introduction

More information

Artificial Intelligence Programming

Artificial Intelligence Programming Artificial Intelligence Programming Rob St. Amant Department of Computer Science North Carolina State University Lisp basics NC State University 2 / 99 Why Lisp? Some recent Lisp success stories include

More information

(defmacro while (condition &body body) `(iterate loop () (if,condition (loop)))))

(defmacro while (condition &body body) `(iterate loop () (if,condition (loop))))) ; PARCIL - A Parser for C syntax In Lisp version 0.1a copyright (c) 1992 by Erann Gat, all rights reserved This program is free software; you can redistribute it and/or modify it under the terms of the

More information

Lecture Notes on Lisp A Brief Introduction

Lecture Notes on Lisp A Brief Introduction Why Lisp? Lecture Notes on Lisp A Brief Introduction Because it s the most widely used AI programming language Because Prof Peng likes using it Because it s good for writing production software (Graham

More information

CS 415 Midterm Exam Spring 2002

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

More information

Allegro CL Certification Program

Allegro CL Certification Program Allegro CL Certification Program Lisp Programming Series Level I Presented by 1 About David Margolies Manager, Documentation, Franz Inc Been working with Lisp since 1984 dm@franz.com 2 About Franz Inc.

More information

Lisp: Question 1. Dr. Zoran Duric () Midterm Review 1 1/ 13 September 23, / 13

Lisp: Question 1. Dr. Zoran Duric () Midterm Review 1 1/ 13 September 23, / 13 Lisp: Question 1 Write a recursive lisp function that takes a list as an argument and returns the number of atoms on any level of the list. For instance, list (A B (C D E) ()) contains six atoms (A, B,

More information

FUNCTIONAL AND LOGIC PROGRAMS

FUNCTIONAL AND LOGIC PROGRAMS FUNCTIONAL AND LOGIC PROGRAMS Contents Language Specific Compilation Context Handling Identification Scope Overloading Imported Scope Type Checking Type table Type equivalence Coercions Casts and conversions

More information

Debugging in LISP. trace causes a trace to be printed for a function when it is called

Debugging in LISP. trace causes a trace to be printed for a function when it is called trace causes a trace to be printed for a function when it is called ;;; a function that works like reverse (defun rev (list) (cons (first (last list)) (rev (butlast list)))) USER: (trace rev) ; note trace

More information

Functional Programming. Pure Functional Languages

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

More information

CS 480. Lisp J. Kosecka George Mason University. Lisp Slides

CS 480. Lisp J. Kosecka George Mason University. Lisp Slides CS 480 Lisp J. Kosecka George Mason University Lisp Slides Symbolic Programming Symbols: +, -, 1, 2 etc. Symbolic expressions: (+ 1 2), (+ (* 3 4) 2) Symbolic programs are programs that manipulate symbolic

More information

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

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

More information

Queue-based Multi-processing Lisp

Queue-based Multi-processing Lisp Queue-based Multi-processing Lisp Richard P. Gabriel John McCarthy Stanford University 1. Introduction As the need for high-speed computers increases, the need for multi-processors will be become more

More information

Racket: Macros. Advanced Functional Programming. Jean-Noël Monette. November 2013

Racket: Macros. Advanced Functional Programming. Jean-Noël Monette. November 2013 Racket: Macros Advanced Functional Programming Jean-Noël Monette November 2013 1 Today Macros pattern-based macros Hygiene Syntax objects and general macros Examples 2 Macros (According to the Racket Guide...)

More information

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

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,

More information

CSci 4223 Lecture 12 March 4, 2013 Topics: Lexical scope, dynamic scope, closures

CSci 4223 Lecture 12 March 4, 2013 Topics: Lexical scope, dynamic scope, closures CSci 4223 Lecture 12 March 4, 2013 Topics: Lexical scope, dynamic scope, closures 1 Lexical Scope SML, and nearly all modern languages, follow the Rule of Lexical Scope: the body of a function is evaluated

More information

Functional Programming. Pure Functional Languages

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

More information

Problem Set 4: Streams and Lazy Evaluation

Problem Set 4: Streams and Lazy Evaluation Due Friday, March 24 Computer Science (1)21b (Spring Term, 2017) Structure and Interpretation of Computer Programs Problem Set 4: Streams and Lazy Evaluation Reading Assignment: Chapter 3, Section 3.5.

More information

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

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

More information

Functions and Recursion. Dr. Philip Cannata 1

Functions and Recursion. Dr. Philip Cannata 1 Functions and Recursion Dr. Philip Cannata 1 10 High Level Languages This Course Java (Object Oriented) Jython in Java Relation ASP RDF (Horn Clause Deduction, Semantic Web) Dr. Philip Cannata 2 let transformation,

More information

CS Lecture 6: Map and Fold. Prof. Clarkson Spring Today s music: Selections from the soundtrack to 2001: A Space Odyssey

CS Lecture 6: Map and Fold. Prof. Clarkson Spring Today s music: Selections from the soundtrack to 2001: A Space Odyssey CS 3110 Lecture 6: Map and Fold Prof. Clarkson Spring 2015 Today s music: Selections from the soundtrack to 2001: A Space Odyssey Review Course so far: Syntax and semantics of (most of) OCaml Today: No

More information

A Brief Introduction to Standard ML

A Brief Introduction to Standard ML A Brief Introduction to Standard ML Specification and Verification with Higher-Order Logic Arnd Poetzsch-Heffter (Slides by Jens Brandt) Software Technology Group Fachbereich Informatik Technische Universität

More information

More Untyped Lambda Calculus & Simply Typed Lambda Calculus

More Untyped Lambda Calculus & Simply Typed Lambda Calculus Concepts in Programming Languages Recitation 6: More Untyped Lambda Calculus & Simply Typed Lambda Calculus Oded Padon & Mooly Sagiv (original slides by Kathleen Fisher, John Mitchell, Shachar Itzhaky,

More information

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

More information

COMP 1130 Lambda Calculus. based on slides by Jeff Foster, U Maryland

COMP 1130 Lambda Calculus. based on slides by Jeff Foster, U Maryland COMP 1130 Lambda Calculus based on slides by Jeff Foster, U Maryland Motivation Commonly-used programming languages are large and complex ANSI C99 standard: 538 pages ANSI C++ standard: 714 pages Java

More information

Meet the Macro. a quick introduction to Lisp macros. Patrick Stein / TC Lisp Users Group /

Meet the Macro. a quick introduction to Lisp macros. Patrick Stein / TC Lisp Users Group / Meet the Macro a quick introduction to Lisp macros Patrick Stein / TC Lisp Users Group / 2009-07-14 Attack Plan Some other things called macros First look at Lisp macros More advanced macros Uh-oh, my

More information

CMSC330. Objects, Functional Programming, and lambda calculus

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

More information

STREAMS 10. Basics of Streams. Practice with Streams COMPUTER SCIENCE 61AS. 1. What is a stream? 2. How does memoization work?

STREAMS 10. Basics of Streams. Practice with Streams COMPUTER SCIENCE 61AS. 1. What is a stream? 2. How does memoization work? STREAMS 10 COMPUTER SCIENCE 61AS Basics of Streams 1. What is a stream? 2. How does memoization work? 3. Is a cons-stream a special form? Practice with Streams 1. Define a procedure (ones) that, when run

More information

Name EID. (calc (parse '{+ {with {x {+ 5 5}} {with {y {- x 3}} {+ y y} } } z } ) )

Name EID. (calc (parse '{+ {with {x {+ 5 5}} {with {y {- x 3}} {+ y y} } } z } ) ) CS 345 Spring 2010 Midterm Exam Name EID 1. [4 Points] Circle the binding instances in the following expression: (calc (parse '+ with x + 5 5 with y - x 3 + y y z ) ) 2. [7 Points] Using the following

More information

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

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

More information

(Func&onal (Programming (in (Scheme)))) Jianguo Lu

(Func&onal (Programming (in (Scheme)))) Jianguo Lu (Func&onal (Programming (in (Scheme)))) Jianguo Lu 1 Programming paradigms Func&onal No assignment statement No side effect Use recursion Logic OOP AOP 2 What is func&onal programming It is NOT what you

More information

1 CLWEB INTRODUCTION 1

1 CLWEB INTRODUCTION 1 1 CLWEB INTRODUCTION 1 1. Introduction. This is CLWEB, a literate programming system for Common Lisp by Alex Plotnick plotnick@cs.brandeis.edu. It is modeled after the CWEB system by Silvio Levy and Donald

More information

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

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

More information

Plumber - A Higher Order Data Flow Visual Programming Language in Lisp. Seika Abe MSI

Plumber - A Higher Order Data Flow Visual Programming Language in Lisp. Seika Abe MSI Plumber - A Higher Order Data Flow Visual Programming Language in Lisp Seika Abe MSI Outline 1. What is DFVPL 2. Plumber 3. Streams 4. Higher order functions 5. Finding monads 1/5. What is DFVPL Dataflow

More information

Functional Programming - 2. Higher Order Functions

Functional Programming - 2. Higher Order Functions Functional Programming - 2 Higher Order Functions Map on a list Apply Reductions: foldr, foldl Lexical scoping with let s Functional-11, CS5314, Sp16 BGRyder 1 Higher Order Functions Functions as 1st class

More information

Project 2: Scheme Interpreter

Project 2: Scheme Interpreter Project 2: Scheme Interpreter CSC 4101, Fall 2017 Due: 12 November 2017 For this project, you will implement a simple Scheme interpreter in C++ or Java. Your interpreter should be able to handle the same

More information

Detection of methods (or missing methods): Cleaning up some details of our implementation. Better Method Convention (1) --self

Detection of methods (or missing methods): Cleaning up some details of our implementation. Better Method Convention (1) --self Cleaning up some details of our implementation Dealing with missing methods The need for self -reference Dealing with tags Detection of methods (or missing methods): Use (no-method) to indicate that there

More information

Introduction to Artificial Intelligence CISC-481/681 Program 1: Simple Lisp Programs

Introduction to Artificial Intelligence CISC-481/681 Program 1: Simple Lisp Programs CISC-481/681 Program 1: Simple Lisp Programs 1 Introduction to Artificial Intelligence CISC-481/681 Program 1: Simple Lisp Programs Reading: Handouts Summarizing Common Lisp Functions Paul Graham s ANSI

More information

Introduction to Lambda Calculus. Lecture 5 CS 565 1/24/08

Introduction to Lambda Calculus. Lecture 5 CS 565 1/24/08 Introduction to Lambda Calculus Lecture 5 CS 565 1/24/08 Lambda Calculus So far, we ve explored some simple but non-interesting languages language of arithmetic expressions IMP (arithmetic + while loops)

More information

CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages 1 / 63 CSE 307: Principles of Programming Languages Syntax R. Sekar Topics 1. Introduction 2. Basics 3. Functions 4. Data Structures 5. Overview 6. OCAML Performance 2 / 63 3 / 63 Section 1 Introduction

More information

CSCI 2210: Programming in Lisp. Progn. Block. CSCI Programming in Lisp; Instructor: Alok Mehta 1. ANSI Common Lisp, Chapters 5-10

CSCI 2210: Programming in Lisp. Progn. Block. CSCI Programming in Lisp; Instructor: Alok Mehta 1. ANSI Common Lisp, Chapters 5-10 CSCI 2210: Programming in Lisp ANSI Common Lisp, Chapters 5-10 CSCI 2210 - Programming in Lisp; Instructor: Alok Mehta; 4.ppt 1 Progn Progn Creates a block of code Expressions in body are evaluated Value

More information

Fifth Generation CS 4100 LISP. What do we need? Example LISP Program 11/13/13. Chapter 9: List Processing: LISP. Central Idea: Function Application

Fifth Generation CS 4100 LISP. What do we need? Example LISP Program 11/13/13. Chapter 9: List Processing: LISP. Central Idea: Function Application Fifth Generation CS 4100 LISP From Principles of Programming Languages: Design, Evaluation, and Implementation (Third Edition, by Bruce J. MacLennan, Chapters 9, 10, 11, and based on slides by Istvan Jonyer

More information

CSE 307: Principles of Programming Languages

CSE 307: Principles of Programming Languages CSE 307: Principles of Programming Languages Syntax R. Sekar 1 / 63 Topics 1. Introduction 2. Basics 3. Functions 4. Data Structures 5. Overview 6. OCAML Performance 2 / 63 Section 1 Introduction 3 / 63

More information

Class 6: Efficiency in Scheme

Class 6: Efficiency in Scheme Class 6: Efficiency in Scheme SI 413 - Programming Languages and Implementation Dr. Daniel S. Roche United States Naval Academy Fall 2011 Roche (USNA) SI413 - Class 6 Fall 2011 1 / 10 Objects in Scheme

More information

Introduction to Lisp

Introduction to Lisp Last update: February 16, 2010 Introduction to Lisp Dana Nau Dana Nau 1 Outline I assume you know enough about computer languages that you can learn new ones quickly, so I ll go pretty fast If I go too

More information

CS450: Structure of Higher Level Languages Spring 2018 Assignment 7 Due: Wednesday, April 18, 2018

CS450: Structure of Higher Level Languages Spring 2018 Assignment 7 Due: Wednesday, April 18, 2018 CS450: Structure of Higher Level Languages Spring 2018 Assignment 7 Due: Wednesday, April 18, 2018 Taken from assignments by Profs. Carl Offner and Ethan Bolker Part 1 - Modifying The Metacircular Evaluator

More information

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

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

More information

CSE 3302 Programming Languages Lecture 8: Functional Programming

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

More information

15 212: Principles of Programming. Some Notes on Continuations

15 212: Principles of Programming. Some Notes on Continuations 15 212: Principles of Programming Some Notes on Continuations Michael Erdmann Spring 2011 These notes provide a brief introduction to continuations as a programming technique. Continuations have a rich

More information

SOFTWARE ARCHITECTURE 6. LISP

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

More information

Scala : an LLVM-targeted Scala compiler

Scala : an LLVM-targeted Scala compiler Scala : an LLVM-targeted Scala compiler Da Liu, UNI: dl2997 Contents 1 Background 1 2 Introduction 1 3 Project Design 1 4 Language Prototype Features 2 4.1 Language Features........................................

More information

MORE SCHEME. 1 What Would Scheme Print? COMPUTER SCIENCE MENTORS 61A. October 30 to November 3, Solution: Solutions begin on the following page.

MORE SCHEME. 1 What Would Scheme Print? COMPUTER SCIENCE MENTORS 61A. October 30 to November 3, Solution: Solutions begin on the following page. MORE SCHEME COMPUTER SCIENCE MENTORS 61A October 30 to November 3, 2017 1 What Would Scheme Print? Solutions begin on the following page. 1. What will Scheme output? Draw box-and-pointer diagrams to help

More information

Lists. Michael P. Fourman. February 2, 2010

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

More information

low and not larger than high. 18 points

low and not larger than high. 18 points CSE 330 Test 1 (1 point) Spring 015 Multiple Choice. Write your answer to the LEFT of each problem. 3 points each 1. Lisp was invented at: A. IBM B. MIT C. Netscape D. Stanford. In C++, what operator is

More information

An Introduction to Scheme

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

More information

CSE341: Programming Languages Winter 2018 Unit 5 Summary Zach Tatlock, University of Washington

CSE341: Programming Languages Winter 2018 Unit 5 Summary Zach Tatlock, University of Washington CSE341: Programming Languages Winter 2018 Unit 5 Summary Zach Tatlock, University of Washington Standard Description: This summary covers roughly the same material as class and recitation section. It can

More information

A Brief Introduction to Scheme (I)

A Brief Introduction to Scheme (I) A Brief Introduction to Scheme (I) Philip W. L. Fong pwlfong@cs.uregina.ca Department of Computer Science University of Regina Regina, Saskatchewan, Canada Scheme Scheme I p.1/44 Scheme: Feature Set A

More information

Lambda Calculus. CS 550 Programming Languages Jeremy Johnson

Lambda Calculus. CS 550 Programming Languages Jeremy Johnson Lambda Calculus CS 550 Programming Languages Jeremy Johnson 1 Lambda Calculus The semantics of a pure functional programming language can be mathematically described by a substitution process that mimics

More information

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

More information

A quick introduction to SML

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

More information

What is tail position?

What is tail position? What is tail position? Tail position is defined inductively: The body of a function is in tail position When(if e1 e2 e3) is in tail position, so are e2 ande3 When(let (...) e) is in tail position, so

More information

Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler Front-End

Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler Front-End Outline Semantic Analysis The role of semantic analysis in a compiler A laundry list of tasks Scope Static vs. Dynamic scoping Implementation: symbol tables Types Static analyses that detect type errors

More information

CS Lecture 6: Map and Fold. Prof. Clarkson Fall Today s music: Selections from the soundtrack to 2001: A Space Odyssey

CS Lecture 6: Map and Fold. Prof. Clarkson Fall Today s music: Selections from the soundtrack to 2001: A Space Odyssey CS 3110 Lecture 6: Map and Fold Prof. Clarkson Fall 2014 Today s music: Selections from the soundtrack to 2001: A Space Odyssey Review Features so far: variables, operators, let expressions, if expressions,

More information

External aids allowed:

External aids allowed: Midterm Duration: External aids allowed: 75 minutes None Make sure that your examination booklet has 8 pages of questions (excluding this one). Write your answers in the space provided. Write legibly.

More information

UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division

UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division Fall, 2001 Prof. R. Fateman SUGGESTED S CS 164 Final Examination: December 18, 2001, 8-11AM

More information

Intro. Scheme Basics. scm> 5 5. scm>

Intro. Scheme Basics. scm> 5 5. scm> Intro Let s take some time to talk about LISP. It stands for LISt Processing a way of coding using only lists! It sounds pretty radical, and it is. There are lots of cool things to know about LISP; if

More information

Vectors in Scheme. Data Structures in Scheme

Vectors in Scheme. Data Structures in Scheme Data Structures in Scheme Vectors in Scheme In Scheme, lists and S-expressions are basic. Arrays can be simulated using lists, but access to elements deep in the list can be slow (since a list is a linked

More information

Part I. Historical Origins

Part I. Historical Origins Introduction to the λ-calculus Part I CS 209 - Functional Programming Dr. Greg Lavender Department of Computer Science Stanford University Historical Origins Foundations of Mathematics (1879-1936) Paradoxes

More information

Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions. 1 Calculator. calc> (+ 2 2) 4

Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions. 1 Calculator. calc> (+ 2 2) 4 CS 61A Interpreters and Tail Calls Fall 2017 Discussion 8: November 1, 2017 Solutions 1 Calculator We are beginning to dive into the realm of interpreting computer programs that is, writing programs that

More information

Pattern Matching for Scheme

Pattern Matching for Scheme Pattern Matching for Scheme Andrew K. Wright March 1996 Department of Computer Science MS 132 Rice University 6100 Main Street Houston, Texas 77005-1892 Contents 1 Match 1 1.1 Definition... 1 1.1.1 Patterns...

More information

CS 342 Lecture 7 Syntax Abstraction By: Hridesh Rajan

CS 342 Lecture 7 Syntax Abstraction By: Hridesh Rajan CS 342 Lecture 7 Syntax Abstraction By: Hridesh Rajan 1 Reading SICP, page 11-19, Section 1.1.6 Little Schemer, Chapter 2 2 The Idea of Syntax Abstraction Problem. Often programming tasks are repetitive,

More information