# Organization of Programming Languages CS3200/5200N. Lecture 11

Save this PDF as:

Size: px
Start display at page:

## Transcription

1 Organization of Programming Languages CS3200/5200N Razvan C. Bunescu School of Electrical Engineering and Computer Science

2 Functional vs. Imperative 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. Heavy reliance on the underlying hardware (unnecessary) restrictions on software development. The design of the functional languages is based on mathematical functions: Offer a solid theoretical basis that is also closer to the user. Relatively unconcerned with the architecture of the machines on which programs will run. 2

3 Mathematical Functions A mathematical function is a mapping of members of one set, called the domain, to another set, called the range: The function square: Z N, square(x) = x * x square is the name of the function x is an element in the domain Z square(x) is the corresponding element in the range N square(x) = x * x defines the mapping. The function fact : N N fact(x) = 1 if x =0 x* fact(x-1) if x > 0 3

4 Lambda Expressions A lambda expression specifies the parameters and the mapping of a nameless function in the following form: λx. x * x is the lambda expression for the mathematical function square(x) = x * x. λx. λy. x + y corresponds to sum(x, y) = x + y Lambda expressions are applied to parameters by placing the parameters after the expression: (λx. x * x * x)(2) evaluates to 8. 4

5 Functional Forms A higher-order function, or functional form, is one that: either takes functions as parameters, or yields a function as its result, or both. Examples of functional forms: functional composition. apply-to-all. 5

6 Functional Composition Mathematical Notation: Form: h f g Meaning: h(x) f(g(x)) Example: f(x) x + 2 and g(x) 3 * x. h f g is equivalent with h(x) (3*x)+2 Lambda expression: λx. x + 2 λx. 3 * x λf. λg. λx. f (g x) 6

7 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. Mathematical notation: Form: α Function: h(x) x * x Example: α(h, (2, 3, 4)) yields (4, 9, 16) Lambda expression: 7

8 Functional Programming and Lambda Calculus Functional languages have a formal semantics derived from Lambda Calculus: Defined by Alonzo Church in the mid 1930s as a computational theory of recursive functions. The lambda calculus emphasizes expressions and functions, which naturally leads to a functional style of programming based on evaluation of expressions by function application to argument values. 8

9 Imperative Programming and Turing Machines Imperative programming: computation is performed through statements that change a program state. Modeled formally using Turing Machines: Defined by Alan Turing in the mid 1930s. Abstract machines that emphasize computation as a series of state transitions driven by symbols on an input tape, which leads naturally to an imperative style of programming based on assignment. 9

10 Functional Languages and Lambda Calculus Theorem (Church, Kleen, Turing): Lambda Calculus and Turing Machines have the same computational power. Functional Languages have a denotational semantics based on lambda calculus: the meaning of all syntactic programming constructs in the language is defined in terms of mathematical functions. 10

11 Scheme Designed and implemented by Steele and Sussman at MIT in Influenced syntactically and semantically by LISP and conceptually by Algol: Lisp contributed the simple syntax, uniform representation of programs as lists and garbage collected heap allocated data. Algol contributed lexical (static) scoping and block structure. Lisp and Algol both defined recursive functions. 11

12 Scheme: Key Features Scheme is statically scoped: uses the let, let* and letrec operators to define variable bindings within local scopes. Scheme has dynamic or latent typing: types are associated with values at run-time. a variable assumes the type of the value that is bound to at run-time. Scheme objects are garbage-collected: run-time objects have potentially unlimited lifetime. Scheme functions are first-class objects: functions can be created dynamically, stored in data structures, returned as results of expressions or other functions. functions are defined as lists can be treated as data. 12

13 Scheme: Key Features Scheme data objects (e.g. lists) are first-class objects: they are all heap-allocated; can be returned as results from functions, and combined to form larger data strucures. Scheme supports many different types: numbers, characters, strings, symbols, and lists. integers, real, complex, and arbitrary precision rational numbers. Scheme includes a large set of built-in functions for manipulation of lists and other data objects. Arguments to functions are always passed by value: actual arguments are always evaluated before a function is called, whether or not the function needs the values (eager, or strict evaluation). 13

14 Syntax and Naming Conventions Scheme programs are made of: keywords, variables, structured forms (e.g. lists), numbers, characters, strings, quoted vectors, quoted lists, whitespace, and comments. Identifiers (keywords, variables and symbols) are formed from the characters a-z, A-Z, 0-9, and?!.+-*/<=>:\$%^&_~ identifiers cannot start with 0-9,-,+. Predicate names end in the question mark symbol: eq?, zero?, string=? Type predicates are the name of the type followed by a?: pair?, string? 14

15 Syntax and Naming Conventions Builtin character, string, and vector functions start with the name of the type: string-append, Functions that convert one type of object to another use the symbol: string number Strings are formed using double quotes: Hello, world! Numbers are just numbers: 100, 3.14 Some function names are overloaded (e.g., +, *, /). 15

16 Simple Expressions An expression in Scheme has the form (E 1 E 2 E n ): E 1 evaluates to an operator. E 2 through E n are evaluated as operands. Some examples using the Dr. Scheme interpreter: ( ) 10 (+ 1 (* 2 3) 4) 11 Scheme does dynamic type checking and automatic type coercion: ( )

17 Simple Expressions Scheme uses inner-most evaluation: arguments are evaluated first, then substituted as parameters to functions: (define (square x) (* x x)) (square (+ 2 3)) (square 5) (* 5 5) 25 once the subexpression (+2 3) is evaluated, the memory for this list can be garbage collected. Functions can also be defined using lambda expressions: (define square (lambda(x) (* x x))) (square 0.1)

18 Top Level Bindings: define A Function for constructing functions define: 1. To bind a symbol to an expression e.g., (define pi ) Example use: (define two_pi (* 2 pi)) 2. To bind names to lambda expressions e.g., (define(square x) (* x x)) Example use: (square 5) The evaluation process for define is different! The first parameter is never evaluated. The second parameter is evaluated and bound to the first parameter. 18

19 Delayed Evaluation: quote quote takes one parameter; returns the parameter w/o evaluation. (quote ( )) ( ) The Scheme interpreter, named eval, always evaluates parameters to function applications before applying the function. Use quote to avoid parameter evaluation when it is not appropriate. Can be abbreviated with the apostrophe prefix operator: ( ) ( ) (eval ( )) 6 (define sum123 ( )) sum123 ( ) (eval sum123) 6 x x 19

20 Predicate Functions Boolean values: #T is true and #F is false sometimes () is used for false. Relational predicates: =, >, <, >=, <= implement <> Numerical predicates: even?, odd?, zero?, negative? 20

21 Predicate Functions: Equality 1. Use eq? to compare two atoms: (eq? a a) #t (eq? ) #f 2. Use eqv? to compare two numbers or characters: (eqv? ) #t (eqv? hello hello ) #f 3. Use equal? to compare two objects for structural equality: (equal? hello hello ) #t 21

22 Builtin Logical Operators Logical operators: (and <e1> <en>) (or <e1> <en> (not <e1>) Parameter evaluation: expressions are evaluated left to right: short-circuit evaluation for and and or. Examples: (and (< x 10) (> x 5) (define (<= x y) (or (< x y) (= x y))) (define (<= x y) (not (> x y))) 22

23 Control Flow: if The special form if: (if <predicate> <then_exp> <else_exp>) (if <predicate> <then_exp>) Examples: (define (abs x) (if (< x 0) (- 0 x) x)) - ((if #f + *) 2 3) 23

24 Control Flow: cond Multiple selection using the special form cond with the general form: (cond (predicate_1 expr {expr}) (predicate_2 expr {expr})... (predicate_k expr {expr}) (else expr {expr})) Returns the value of the last expression in the first pair whose predicate evaluates to true 24

25 Control Flow: cond (define (abs x) (cond ((< x 0) (- 0 x)) (else x))) (define (compare x y) (cond ((> x y) x is greater than y ) ((< x y) y is greater than x ) (else x and y are equal ))) 25

26 Factorial in Scheme (define (factorial x) (if (= x 0) 1 (* x (factorial (- x 1))))) (define factorial (lambda (x) (if (= x 0) 1 (* x (factorial (- x 1))))) 26

27 Lambda Expressions in Scheme (lambda (<formal parameters>) <body>) When the lambda expression is evaluated, the environment in which it is evaluated is remembered. When the procedure is called, the environment is augmented with bindings of formal params to actual params. The expressions in the body are evaluated sequentially in order. Example: ((lambda (x y) (* x y) ) 2 3) ;; multiply 2 with 3 27

28 Let Expressions Allow the definition of local variable bindings. General form: (let((<name1> <expression1>) (<name2> <expression2>)... body (<namek> <expressionk>)) ) Evaluate all expressions; Bind the values to the names; Evaluate the body. 28

29 Let Expressions (define pi 3.14) (define (sum-of-pi-squared) (+ (square pi) (square pi))) (define (sum-of-pi-squared) (let ((pi-squared (square pi))) (+ pi-squared pi-squared))) Which is more efficient? 29

30 Let Expressions are Lambda Expressions Syntactic sugar for lambda expressions: ((lambda (<name1> <namek>) <expr1> (<body>)) <exprk>) the result of the lambda expression is an anonymous procedure. all the argument expressions are evaluated before the procedure is called (because of call-by-value semantics). when the procedure is called, the variables for the formal parameters are bound to the values of the argument expressions and used in evaluating the body of the procedure. 30

31 Let* Expressions General form: (let* ((<name1> <expression1>) ) body (<name2> <expression2>)... (<namek> <expressionk>)) The bindings are performed sequentially, from left to right. earlier variable bindings apply to later variable bindings. 31

32 Let* Expressions are Lambda Expressions Let* examples: (define x 0) x 0 (let ((x 2) (y x)) y) 0 (let* ((x 2) (y x)) y) 2 Binding order is important lexically nest the lambda expressions and the application to arguments: ((lambda (x) ((lambda (y) y) x)) 2) 2 32

33 Lists in Scheme Almost everything in Scheme is a list: the interpreter evaluates most lists as an operator followed by operands, and returns a result. ( ) 10 list is evaluated as an expression, result is 10. ( ) ( ) result is a list of symbols the empty list is denoted by (). Examples: (colorless green ideas sleep furiously) ((green) ideas (((sleep) furiously)) ()) 33

34 List Operations: car and cdr car takes a list parameter; returns the first element of that list e.g. (car '(A B C)) yields A (car '((A B) C D)) yields (A B) cdr takes a list parameter; returns the list after removing its first element e.g. (cdr '(A B C)) yields (B C) (cdr '((A B) C D)) yields (C D) 34

35 List Creation: cons and list cons: takes two parameters: the first can be either an atom or a list; the second is a list; returns a new list that includes the first parameter as its first element and the second parameter as the remainder. (cons 'A '(B C)) (A B C) list: takes any number of parameters; returns a list with the parameters as elements. (list a b c) (a b c) 35

36 Pairs cons can also be used to create pairs or improper lists: > (cons a b) (a. b) > (car (a. b)) a > (cdr (a. b)) b When the second argument is a list, the result is a list: > (cons a (b)) (a b) > (car (a b)) a > (cdr (a b)) (b) 36

37 Predicates on Lists list? takes one parameter; it returns #t if the parameter is a list; otherwise #f (list? ()) #t (list? (cons a ())) #t null? takes one parameter; it returns #t if the parameter is the empty list; otherwise #f (null? ()) #t equal? (equal? (a b) (list a b)) #t 37

38 Scheme Functions: Example member takes as parameters an atom and a simple list: returns #t if the atom is in the list; returns #f otherwise. (define (member atom list) (cond ((null? list) #f) ((eq? atom (car list)) #t) (else (member atom (cdr list))) ) ) 38

39 Scheme Functions: Example equalsimp takes two simple lists as parameters: returns #T if the two simple lists are equal; returns #F otherwise. (define (equalsimp lis1 lis2) (cond ((null? lis1) (null? lis2)) ((null? lis2) #F) ((eq? (car lis1) (car lis2)) (equalsimp (cdr lis1)(cdr lis2))) (else #F) )) 39

40 Scheme Functions: Example equal takes two general lists as parameters: returns #T if the two lists are equal; returns #F otherwise. (define (equal list1 list2) (cond ((not (list? list1))(eq? list1 list2)) ((not (list? list2)) #F) ((null? list1) (null? list2)) ((null? list2) #F) ((equal (car list1) (car list2)) (equal (cdr list1) (cdr list2))) (else #F))) 40

41 Scheme Functions: Example append takes two lists as parameters: returns the first parameter list with the elements of the second parameter list appended at the end. (define (append list1 list2) ) (cond ) ((null? list1) list2) (else (cons (car list1) (append (cdr list1) list2))) 41

42 Functional Forms in Scheme Functional Composition: (cdr (cdr '(A B C))) (C) HW: define a function that is the composition of cdr with cdr. Apply-to-All: one form in Scheme is map, which applies a given function to all elements of a given list. (define (map fun lis) )) (cond ((null? lis) ()) (else (cons (fun (car lis)) (map fun (cdr lis)))) 42

43 Procedures That Return Procedures > (define (make-adder (num) (lambda (x) (+ x num))) > ((make-adder 10) 9)? > ((lambda (x) (+ x 10)) 9)? 43

44 Functions that build Scheme 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. 44

45 Functions that build Scheme code Building a function that adds a list of numbers: (define (adder lis) (cond ((null? lis) 0) (else (eval (cons '+ lis) (scheme-report-environment 5) ))) The parameter is a list of numbers to be added; adder inserts a + operator and evaluates the resulting list. Use cons to insert the atom + into the list of numbers. Be sure that + is quoted to prevent evaluation. Submit the new list to eval for evaluation. 45

46 Conceptually Infinite Lists in Scheme A doomed attempt to define the infinite list of integers: > (define ints (lambda (n) (cons n (ints (+ n 1))))) > (define integers (ints 1)) 46

47 Conceptually Infinite Lists in Scheme Delayed Evaluation: delay the creation of remaining integers until needed. > (define ints (lambda (n) (cons n (lambda () (ints (+ n 1)))))) > (define integers (ints 1)) > integers (1. #<procedure>) How do we access elements in the list? 47

48 Conceptually Infinite Lists in Scheme Head can get the head with car: > (define head car) > (head integers) Value: 1 Tail must force the evaluation of the tail: > (define tail (lambda (list) ((cdr list)))) > (tail integers) (2. #<procedure>) > (head (tail (tail integers)))? 48

49 Conceptually Infinite Lists in Scheme Element get the n-th integer: > (define element (lambda (n list) (if (= n 1) (head list) (element (- n 1) (tail list))))) > (element 6 integers) 6 > (element 6 (tail integers))? 49

50 Conceptually Infinite Lists in Scheme Take get the first n integers: > (define take (lambda (n list) (if (= n 0) '() (cons (head list) (take (- n 1) (tail list)))))) > (take 5 integers) ( ) > (take 3 (tail integers))? 50

51 The Fibonacci Numbers The Fibonacci numbers as a conceptually infinite list: > (define fibs (lambda (a b) (cons a (lambda () (fibs b (+ a b)))))) > (define fibonacci (fibs 1 1)) > (take 10 fibonacci) ( ) > (element 10 (tail fibonacci))? 51

52 The Sum of Two Infinite Lists > (define sum (lambda (list1 list2) (cons (+ (head list1) (head list2)) (lambda () (sum (tail list1) (tail list2)))))) > (take 10 (sum integers integers)) ( ) > (take 5 (sum integers fibonacci)? 52

53 The Sum of Two Infinite Lists What does the following list correspond to? > (define foo (cons 1 (lambda () (cons 1 (lambda () (sum foo (tail foo))))))) > (take 10 foo)? 53

54 Reading Assignment Chapter 10 from the textbook (10.1, 10.2, 10.3, 10.5, 10.7): ignore imperative features (e.g. assignment, iteration). Chapters 1 & 2 from the Scheme programming book at ignore imperative features (e.g. assignment, iteration). DrScheme is installed on the prime machines (p1 & p2). you can also install it on your Win/Linux/Mac machine by downloading it from racket-lang.org. Familiarize yourself with the Scheme interpreter by typing in examples from the textbook or lecture notes. set the language to Standard (R6RS). 54

### Functional Programming. Pure Functional Languages

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

### Functional Programming. Pure Functional Languages

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

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

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

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

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

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

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

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

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

### Principles of Programming Languages

Principles of Programming Languages www.cs.bgu.ac.il/~ppl172 Lesson 6 - Defining a Programming Language Bottom Up Collaboration and Management - Elements of Programming Dana Fisman 1 What we accomplished

### Scheme Quick Reference

Scheme Quick Reference COSC 18 Fall 2003 This document is a quick reference guide to common features of the Scheme language. It is not intended to be a complete language reference, but it gives terse summaries

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

### A Brief Introduction to Scheme (II)

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

### CS 314 Principles of Programming Languages. Lecture 16

CS 314 Principles of Programming Languages Lecture 16 Zheng Zhang Department of Computer Science Rutgers University Friday 28 th October, 2016 Zheng Zhang 1 CS@Rutgers University Class Information Reminder:

### Scheme as implemented by Racket

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

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

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

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

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

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

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

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

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

### 9/23/2014. Why study? Lambda calculus. Church Rosser theorem Completeness of Lambda Calculus: Turing Complete

Dr A Sahu Dept of Computer Science & Engineering IIT Guwahati Why study? Lambda calculus Syntax Evaluation Relationship to programming languages Church Rosser theorem Completeness of Lambda Calculus: Turing

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

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

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

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

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

### Essentials of Programming Languages Language

Essentials of Programming Languages Language Version 6.90.0.26 April 20, 2018 The Essentials of Programming Languages language in DrRacket provides a subset of functions and syntactic forms of racket mostly

### Recursive Functions of Symbolic Expressions and Their Application, Part I

Recursive Functions of Symbolic Expressions and Their Application, Part I JOHN MCCARTHY Review: Amit Kirschenbaum Seminar in Programming Languages Recursive Functions of Symbolic Expressions and Their

### Functional Languages and Higher-Order Functions

Functional Languages and Higher-Order Functions Leonidas Fegaras CSE 5317/4305 L12: Higher-Order Functions 1 First-Class Functions Values of some type are first-class if They can be assigned to local variables

### Revised 5 Report on the Algorithmic Language Scheme

HIGHER-ORDER AND SYMBOLIC COMPUTATION 11, 7 105 (1998) Revised 5 Report on the Algorithmic Language Scheme H. ABELSON, R.K. DYBVIG, C.T. HAYNES, G.J. ROZAS, N.I. ADAMS IV, D.P. FRIEDMAN, E. KOHLBECKER,

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

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

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

### Polymorphic lambda calculus Princ. of Progr. Languages (and Extended ) The University of Birmingham. c Uday Reddy

06-02552 Princ. of Progr. Languages (and Extended ) The University of Birmingham Spring Semester 2016-17 School of Computer Science c Uday Reddy2016-17 Handout 6: Polymorphic Type Systems 1. Polymorphic

### Denotational Semantics. Domain Theory

Denotational Semantics and Domain Theory 1 / 51 Outline Denotational Semantics Basic Domain Theory Introduction and history Primitive and lifted domains Sum and product domains Function domains Meaning

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

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

PROGRAMMING IN HASKELL Chapter 2 - First Steps 0 The Hugs System Hugs is an implementation of Haskell 98, and is the most widely used Haskell system; The interactive nature of Hugs makes it well suited

### CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal)

CS61A Discussion Notes: Week 11: The Metacircular Evaluator By Greg Krimer, with slight modifications by Phoebus Chen (using notes from Todd Segal) What is the Metacircular Evaluator? It is the best part

### Lambda Calculus alpha-renaming, beta reduction, applicative and normal evaluation orders, Church-Rosser theorem, combinators

Lambda Calculus alpha-renaming, beta reduction, applicative and normal evaluation orders, Church-Rosser theorem, combinators Carlos Varela Rennselaer Polytechnic Institute February 11, 2010 C. Varela 1

### Ruby: Introduction, Basics

Ruby: Introduction, Basics Computer Science and Engineering College of Engineering The Ohio State University Lecture 4 Ruby vs Java: Similarities Imperative and object-oriented Classes and instances (ie

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

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

### CSCE 314 Programming Languages

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

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

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

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

### Functional abstraction. What is abstraction? Eating apples. Readings: HtDP, sections Language level: Intermediate Student With Lambda

Functional abstraction Readings: HtDP, sections 19-24. Language level: Intermediate Student With Lambda different order used in lecture section 24 material introduced much earlier sections 22, 23 not covered

### Functional abstraction

Functional abstraction Readings: HtDP, sections 19-24. Language level: Intermediate Student With Lambda different order used in lecture section 24 material introduced much earlier sections 22, 23 not covered

### CS 415 Midterm Exam Fall 2003

CS 415 Midterm Exam Fall 2003 Name KEY Email Address Student ID # Pledge: This exam is closed note, closed book. Questions will be graded on quality of answer. Please supply the best answer you can to

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

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

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

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

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

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

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

### CSC312 Principles of Programming Languages : Functional Programming Language. Copyright 2006 The McGraw-Hill Companies, Inc.

CSC312 Principles of Programming Languages : Functional Programming Language Overview of Functional Languages They emerged in the 1960 s with Lisp Functional programming mirrors mathematical functions:

### Tail Recursion. ;; a recursive program for factorial (define fact (lambda (m) ;; m is non-negative (if (= m 0) 1 (* m (fact (- m 1))))))

Tail Recursion 1 Tail Recursion In place of loops, in a functional language one employs recursive definitions of functions. It is often easy to write such definitions, given a problem statement. Unfortunately,

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

### SMURF Language Reference Manual Serial MUsic Represented as Functions

SMURF Language Reference Manual Serial MUsic Represented as Functions Richard Townsend, Lianne Lairmore, Lindsay Neubauer, Van Bui, Kuangya Zhai {rt2515, lel2143, lan2135, vb2363, kz2219}@columbia.edu

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

### Introduction to the Lambda Calculus. Chris Lomont

Introduction to the Lambda Calculus Chris Lomont 2010 2011 2012 www.lomont.org Leibniz (1646-1716) Create a universal language in which all possible problems can be stated Find a decision method to solve

### Scheme: Strings Scheme: I/O

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

### CIS 500 Software Foundations Fall September 25

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

### INF 212 ANALYSIS OF PROG. LANGS LAMBDA CALCULUS. Instructors: Crista Lopes Copyright Instructors.

INF 212 ANALYSIS OF PROG. LANGS LAMBDA CALCULUS Instructors: Crista Lopes Copyright Instructors. History Formal mathematical system Simplest programming language Intended for studying functions, recursion

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

### Reasoning About Programs Panagiotis Manolios

Reasoning About Programs Panagiotis Manolios Northeastern University March 22, 2012 Version: 58 Copyright c 2012 by Panagiotis Manolios All rights reserved. We hereby grant permission for this publication

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

### ALISP interpreter in Awk

ALISP interpreter in Awk Roger Rohrbach 1592 Union St., #94 San Francisco, CA 94123 January 3, 1989 ABSTRACT This note describes a simple interpreter for the LISP programming language, written in awk.

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

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

### How to Design Programs

How to Design Programs How to (in Racket): represent data variants trees and lists write functions that process the data See also http://www.htdp.org/ 1 Running Example: GUIs Pick a fruit: Apple Banana

### λ calculus Function application Untyped λ-calculus - Basic Idea Terms, Variables, Syntax β reduction Advanced Formal Methods

Course 2D1453, 2006-07 Advanced Formal Methods Lecture 2: Lambda calculus Mads Dam KTH/CSC Some material from B. Pierce: TAPL + some from G. Klein, NICTA Alonzo Church, 1903-1995 Church-Turing thesis First

### 9/21/17. Outline. Expression Evaluation and Control Flow. Arithmetic Expressions. Operators. Operators. Notation & Placement

Outline Expression Evaluation and Control Flow In Text: Chapter 6 Notation Operator evaluation order Operand evaluation order Overloaded operators Type conversions Short-circuit evaluation of conditions

### CSc 520 Principles of Programming Languages. Examining Lists. Constructing Lists... 7: Scheme List Processing

Constructing Lists CSc 520 Principles of Programming Languages 7: Scheme List Processing Christian Collberg collberg@cs.arizona.edu Department of Computer Science University of Arizona The most important

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

### Scheme Basics > (butfirst '(help!)) ()

Scheme Basics > (butfirst '(help!)) () [The butfirst of a *sentence* containing one word is all but that word, i.e., the empty sentence. (BUTFIRST 'HELP!) without the inner parentheses would be butfirst

### Formal Semantics. Aspects to formalize. Lambda calculus. Approach

Formal Semantics Aspects to formalize Why formalize? some language features are tricky, e.g. generalizable type variables, nested functions some features have subtle interactions, e.g. polymorphism and

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

### Ruby: Introduction, Basics

Ruby: Introduction, Basics Computer Science and Engineering College of Engineering The Ohio State University Lecture 4 Ruby vs Java: Similarities Imperative and object-oriented Classes and instances (ie

### Project 5 - The Meta-Circular Evaluator

MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs Fall Semester, 2005 Project 5 - The Meta-Circular

### Data Types The ML Type System

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

### How to Design Programs Languages

How to Design Programs Languages Version 4.1 August 12, 2008 The languages documented in this manual are provided by DrScheme to be used with the How to Design Programs book. 1 Contents 1 Beginning Student

### MetacircularScheme! (a variant of lisp)

MetacircularScheme! (a variant of lisp) Lisp = Beauty Passed on through ages Basic Expressions (function arg1 arg2 ) To evaluate an expression, apply the functionto the arguments. (+ 1 2)? => 3 (sqrt4)?

### Ruby: Introduction, Basics

Ruby: Introduction, Basics Computer Science and Engineering College of Engineering The Ohio State University Lecture 3 Ruby vs Java: Similarities Imperative and object-oriented Classes and instances (ie

### Introduction to Lambda Calculus. Lecture 7 CS /08/09

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

### Project 5 - The Meta-Circular Evaluator

MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs Spring Semester, 2005 Project 5 - The Meta-Circular

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

### functional programming in Python, part 2

Programming Languages Week 2 functional programming in Python, part 2 College of Information Science and Engineering Ritsumeikan University review of part 1 eliminating assignment makes programs easier

### Programming Languages Third Edition. Chapter 9 Control I Expressions and Statements

Programming Languages Third Edition Chapter 9 Control I Expressions and Statements Objectives Understand expressions Understand conditional statements and guards Understand loops and variation on WHILE

### The Warhol Language Reference Manual

The Warhol Language Reference Manual Martina Atabong maa2247 Charvinia Neblett cdn2118 Samuel Nnodim son2105 Catherine Wes ciw2109 Sarina Xie sx2166 Introduction Warhol is a functional and imperative programming

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

### Warm-up and Memoization

CSE341 Spring 05 Due Wednesday, May 11 Assignment 4 Part I Warm-up and Memoization Warm-up As a warm-up, write the following Scheme functions: 1. Write the function foldl of the form (foldl func initial

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

### The Metalanguage λprolog and Its Implementation

The Metalanguage λprolog and Its Implementation Gopalan Nadathur Computer Science Department University of Minnesota (currently visiting INRIA and LIX) 1 The Role of Metalanguages Many computational tasks

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

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

### COAL (COmplex Arithmetic Language) Reference Manual

COAL (COmplex Arithmetic Language) Reference Manual March 09, 2009 COMS W4115 Eliot Scull (CVN) e.scull@computer.org 1 Introduction This manual describes the COAL language (COmplex Arithmetic Language)

### ENVIRONMENT DIAGRAMS AND RECURSION 2

ENVIRONMENT DIAGRAMS AND RECURSION 2 COMPUTER SCIENCE 61A February 4, 2016 1 Environment Diagrams An environment diagram keeps track of all the variables that have been defined and the values they are