Cost of Substitution
|
|
|
- Alfred Griffith
- 5 years ago
- Views:
Transcription
1 Cost of Substitution (interp {with {x 1} {with {y 2} {+ 100 {+ 99 { {+ y x}}}}}} ) (interp {with {y 2} {+ 100 {+ 99 { {+ y 1}}}}} ) (interp {+ 100 {+ 99 { {+ 2 1}}}} ) With n variables, evaluation will take O(n 2 ) time! 1-4
2 Deferring Substitution (interp {with {x 1} {with {y 2} {+ 100 {+ 99 { {+ y x}}}}}} ) x = 1 (interp {with {y 2} {+ 100 {+ 99 { {+ y x}}}}} ) y = 2 x = 1 (interp {+ 100 {+ 99 { {+ y x}}}} )... (interp y y = 2 x = 1 ) 5-8
3 Deferring Substitution with the Same Identifier (interp {with {x 1} {with {x 2} x}} ) (interp {with {x 2} x} x = 1 ) (interp x x = 2 x = 1 ) Always add to start, then always check from start 9-12
4 Representing Deferred Substitution Change ; interp : WAE -> num to ; interp : WAE DefrdSub -> num (define-type DefrdSub [mtsub] [asub (name symbol?) (value number?) (rest DefrdSub?)]) 13-14
5 Interp with DefrdSub (interp {with {x 1} {with {y 2} {+ 100 {+ 99 { {+ y x}}}}}} (mtsub)) (interp {with {y 2} {+ 100 {+ 99 { {+ y x}}}}} (asub 'x 1 (mtsub))) (interp {+ 100 {+ 99 { {+ y x}}}}... (asub 'y 2 (asub 'x 1 (mtsub)))) (interp y (asub 'y 2 (asub 'x 1 (mtsub)))) 15-18
6 WAE Interpreter with Deferred Substitutions ; interp : WAE DefrdSub -> num (define (interp a-wae ds) (type-case WAE a-wae [num (n) n] [add (l r) (+ (interp l ds) (interp r ds))] [sub (l r) (- (interp l ds) (interp r ds))] [with (bound-id named-expr body-expr)...] [id (name)...])) 19
7 WAE Interpreter with Deferred Substitutions ; interp : WAE DefrdSub -> num (define (interp a-wae ds) (type-case WAE a-wae [num (n) n] [add (l r) (+ (interp l ds) (interp r ds))] [sub (l r) (- (interp l ds) (interp r ds))] [with (bound-id named-expr body-expr)...] [id (name) (lookup name ds)])) 20
8 WAE Interpreter with Deferred Substitutions ; lookup : symbol DefrdSub -> num (define (lookup name ds) (type-case DefrdSub ds [mtsub () (error 'lookup "free variable")] [asub (sub-name num rest-ds) (if (symbol=? sub-name name) num (lookup name rest-ds))])) 21
9 WAE Interpreter with Deferred Substitutions ; interp : WAE DefrdSub -> num (define (interp a-wae ds) (type-case WAE a-wae [num (n) n] [add (l r) (+ (interp l ds) (interp r ds))] [sub (l r) (- (interp l ds) (interp r ds))] [with (bound-id named-expr body-expr)...] [id (name) (lookup name ds)])) 22
10 WAE Interpreter with Deferred Substitutions ; interp : WAE DefrdSub -> num (define (interp a-wae ds) (type-case WAE a-wae [num (n) n] [add (l r) (+ (interp l ds) (interp r ds))] [sub (l r) (- (interp l ds) (interp r ds))] [with (bound-id named-expr body-expr)... (interp named-expr ds)...] [id (name) (lookup name ds)])) 23
11 WAE Interpreter with Deferred Substitutions ; interp : WAE DefrdSub -> num (define (interp a-wae ds) (type-case WAE a-wae [num (n) n] [add (l r) (+ (interp l ds) (interp r ds))] [sub (l r) (- (interp l ds) (interp r ds))] [with (bound-id named-expr body-expr)... (asub bound-id (interp named-expr ds) ds)...] [id (name) (lookup name ds)])) 24
12 WAE Interpreter with Deferred Substitutions ; interp : WAE DefrdSub -> num (define (interp a-wae ds) (type-case WAE a-wae [num (n) n] [add (l r) (+ (interp l ds) (interp r ds))] [sub (l r) (- (interp l ds) (interp r ds))] [with (bound-id named-expr body-expr) (interp body-expr (asub bound-id (interp named-expr ds) ds))] [id (name) (lookup name ds)])) 25
13 {deffun {f x} {+ 1 x}} Function Calls (interp {with {y 2} {f 10}} ) (interp {f 10} (interp {+ 1 x} y = 2 )... ) 26-28
14 {deffun {f x} {+ 1 x}} Function Calls (interp {with {y 2} {f 10}} ) (interp {f 10} (interp {+ 1 x} y = 2 ) x = 10 ) Interpreting function body starts with only one substitution 29
15 F1WAE Interpreter with Deferred Substitutions ; interp : F1WAE list-of-fundef DefrdSub -> num (define (interp a-f1wae fundefs ds) (type-case F1WAE a-f1wae... [app (name arg-expr)...])) 30
16 F1WAE Interpreter with Deferred Substitutions ; interp : F1WAE list-of-fundef DefrdSub -> num (define (interp a-f1wae fundefs ds) (type-case F1WAE a-f1wae... [app (name arg-expr) (local [(define a-fundef (lookup-fundef name fundefs))] (interp (fundef-body a-fundef) fundefs... (interp arg-expr fundefs ds)...))])) 31
17 F1WAE Interpreter with Deferred Substitutions ; interp : F1WAE list-of-fundef DefrdSub -> num (define (interp a-f1wae fundefs ds) (type-case F1WAE a-f1wae... [app (name arg-expr) (local [(define a-fundef (lookup-fundef name fundefs))] (interp (fundef-body a-fundef) fundefs (asub (fundef-arg-name a-fundef) (interp arg-expr fundefs ds) (mtsub))))])) 32
Higher-Order Functions
Higher-Order Functions 1 Why Functions as Values Abstraction is easier with functions as values abstract over add and sub cases filter, map, etc. What are objects? Callbacks? Separate deffun form becomes
Higher-Order Functions (Part I)
Higher-Order Functions (Part I) 1 Why Functions as Values Abstraction is easier with functions as values abstract over add and sub cases filter, map, etc. What are objects? Callbacks? Separate deffun form
An Introduction to Functions
Chapter 4 An Introduction to Functions Through the agency of with, we have added identifiers and the ability to name expressions to the language. Much of the time, though, simply being able to name an
Threads. {seqn {spawn EXPR 1 } {spawn EXPR 2 }} Runs EXPR 1 and EXPR 2 in any order, even interleaved with each other
Sequential Programs So far, the language that we ve implemented is deterministic. Running a program multiple times (or computing things slightly more quickly or slowly) does not change the result of the
Typed Recursion {with {mk-rec : (((num -> num) -> (num -> num)) -> (num -> num)) {fun {body : ((num -> num) -> (num -> num))} {{fun {fx :
Recursion {with {mk-rec {fun {body} {{fun {fx} {fx fx}} {fun {fx} {{fun {f} {body f}} {fun {x} {{fx fx} x}}}}}}} {with {fib {mk-rec {fun {fib} {fun {n} {if0 n 1 {if0 {- n 1} 1 {+ {fib {- n 1}} {fib {-
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,
cs173: Programming Languages Final Exam
cs173: Programming Languages Final Exam Fall 2002 Please read this page of instructions before you turn the page! This exam is worth 102 points. We will assign partial credit to partial responses, provided
Random Testing in 321
Random Testing in 321 1 Test Cases So Far Each test relates a particular input to a particular output. (test (bound-ids (with 'x (id 'y) (id 'x))) '(x)) (test (binding-ids (with 'x (id 'y) (id 'x))) '(x))
cs173: Programming Languages Midterm Exam
cs173: Programming Languages Midterm Exam Fall 2002 Please read this page of instructions before you turn the page! This exam is worth 181 points. We will assign partial credit to partial responses, provided
Administrative Stuff
Administrative Stuff Use the new version of PLAI from planet. It will download the first time you run a program with the 7, like this: #lang planet plai/plai:1:7 This lets you ignore passing test cases
Non-Functional Procedures
Functional Programs So far, the language that we ve implemented is purely functional A function produces the same result every time for the same arguments Real programming languages do not behave this
Implementing Recursion
Implementing Recursion Shriram Krishnamurthi 2003-09-19 We ve seen that there are (at least two, fairly distinct ways of representing environments To implement recursive environments, we need to provide
"Good" vs. "Bad" Expressions. ; interp-expr FAE... -> FAE-Value
"Good" vs. "Bad" Expressions ; interp-expr FAE... -> FAE-Value 1 "Good" vs. "Bad" Expressions ; interp-expr FAE... -> FAE-Value Does interp-expr produce a value for all expressions? 2 "Good" vs. "Bad"
Random Testing in 321
Random Testing in 321 1 Test Cases So Far Each test relates a particular input to a particular output. (test (bound-ids (with 'x (id 'y) (id 'x))) '(x)) (test (binding-ids (with 'x (id 'y) (id 'x))) '(x))
State. Substitution relies on an identifer having a fxed value
Part 1 1 State Substitution relies on an identifer having a fxed value {let {[x 5]} {let {[f {lambda {y} {+ x y}}]}... {f 1}}} = {let {[f {lambda {y} {+ 5 y}}]}... {f 1}} because x cannot change In Plait,
Functions and Recursion
Programming Languages Functions and Recursion Dr. Philip Cannata 1 10 High Level Languages This Course Jython in Java Java (Object Oriented) ACL2 (Propositional Induction) Relation Algorithmic Information
Functions & First Class Function Values
Functions & First Class Function Values PLAI 1st ed Chapter 4, PLAI 2ed Chapter 5 The concept of a function is itself very close to substitution, and to our with form. Consider the following morph 1 {
Bindings & Substitution
Bindings & Substitution Even in our simple language, we encounter repeated expressions. 1 {* {+ 4 2} {+ 4 2}} There are several reasons to eliminate duplicated code. It introduces a redundant computation.
Running FAE Programs Natively
Running FAE Programs Natively So far: explained various language constructs by using Scheme Explaining Scheme? Certain parts explained using simpler parts of Scheme Leftover parts explained by reduction
Implementing Continuations
Implementing Continuations sk and dbtucker 2002-10-18 1 Changing Representations Now that we ve seen how continuations work, let s study how to implement them in an interpreter. For this lecture onward,
Type Soundness. Type soundness is a theorem of the form If e : τ, then running e never produces an error
Type Soundness Type soundness is a theorem of the form If e : τ, then running e never produces an error 1 Type Soundness Type soundness is a theorem of the form If e : τ, then running e never produces
cs173: Programming Languages
The questions on this exam are worth 100 points. Exam rules: cs173: Programming Languages Midterm Exam Fall 2000 Your responses to this exam are due before the start of class on 2000-11-08. If you believe
Name SOLUTIONS EID NOTICE: CHEATING ON THE MIDTERM WILL RESULT IN AN F FOR THE COURSE.
CS 345 Fall TTh 2012 Midterm Exam B Name SOLUTIONS EID NOTICE: CHEATING ON THE MIDTERM WILL RESULT IN AN F FOR THE COURSE. 1. [5 Points] Give two of the following three definitions. [2 points extra credit
Lexical Addresses. let x = 1 y = 2 in let f = proc (x) +(x, y) in (f x) let _ = 1 _ = 2 in let _ = proc (_) +(<0,0>, <1,1>) in (<0,0> <1,0>)
Lexical Addresses As we saw in the last lecture, the expression might be compiled to let x = 1 y = 2 in let f = proc (x) +(x, y) in (f x) let _ = 1 _ = 2 in let _ = proc (_) +(, ) in ( )
Type Declarations. [... <id> τ... ] <id> : τ. Γ <num> : number. Γ true : boolean. Γ false : boolean. Γ e 1 : number.
![Type Declarations. [... <id> τ... ] <id> : τ. Γ <num> : number. Γ true : boolean. Γ false : boolean. Γ e 1 : number.](/thumbs/95/123652061.jpg "Type Declarations. [... <id> τ... ] <id> : τ. Γ <num> : number. Γ true : boolean. Γ false : boolean. Γ e 1 : number.")
Type Inference 1 Type Declarations Γ : number Γ true : boolean Γ e 1 : number [... τ... ] : τ Γ false : boolean Γ e 2 : number Γ {+ e 1 e 2 } : number Γ e 1 : boolean Γ e 2 : τ 0 Γ e 3
Mid-Term 2 Grades
Mid-Term 2 Grades 100 46 1 HW 9 Homework 9, in untyped class interpreter: Add instanceof Restrict field access to local class Implement overloading (based on argument count) Due date is the same as for
Types and evaluation
Type Soundness 1 Types and evaluation Why is a type system useful? It can rule out ill-formed programs before we run them What information can a type system give us? The type of data the program should
Type Declarations. Γ <num> : num [... <id> τ... ] <id> : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ. {+ e 1 e 2 } : num
![Type Declarations. Γ <num> : num [... <id> τ... ] <id> : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ. {+ e 1 e 2 } : num](/thumbs/81/84354042.jpg "Type Declarations. Γ <num> : num [... <id> τ... ] <id> : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ. {+ e 1 e 2 } : num")
Type Declarations Γ : num [... τ... ] : τ Γ true : bool Γ false : bool Γ e 1 : num Γ e 2 : num Γ {+ e 1 e 2 } : num Γ e 1 : bool Γ e 2 : τ 0 Γ e 3 : τ 0 Γ {if e 1 e 2 e 3 } : τ 0 Γ[
Names and Types. standard hue names. Dr. Philip Cannata 1
Names and Types standard hue names Dr. Philip Cannata 1 10 High Level Languages This Course Jython in Java Java (Object Oriented) ACL2 (Propositional Induction) Relation Algorithmic Information Theory
Comp 411 Principles of Programming Languages Lecture 7 Meta-interpreters. Corky Cartwright January 26, 2018
Comp 411 Principles of Programming Languages Lecture 7 Meta-interpreters Corky Cartwright January 26, 2018 Denotational Semantics The primary alternative to syntactic semantics is denotational semantics.
CPSC 311, 2011W1 Midterm Exam #2 2011/11/09
CPSC 311, 2011W1 Midterm Exam #2 Page 1 of 18 CPSC 311, 2011W1 Midterm Exam #2 2011/11/09 Name: Sample Solution Student ID: Signature (required; indicates agreement with rules below): Q1: 20 Q2: 20 Q3:
Environments
Environments PLAI Chapter 6 Evaluating using substitutions is very inefficient To work around this, we want to use a cache of substitutions. We begin evaluating with no cached substitutions, then collect
Quick announcement. Midterm date is Wednesday Oct 24, 11-12pm.
Quick announcement Midterm date is Wednesday Oct 24, 11-12pm. The lambda calculus = ID (λ ID. ) ( ) The lambda calculus (Racket) = ID (lambda (ID) ) ( )
Parsing Scheme (+ (* 2 3) 1) * 1
Parsing Scheme + (+ (* 2 3) 1) * 1 2 3 Compiling Scheme frame + frame halt * 1 3 2 3 2 refer 1 apply * refer apply + Compiling Scheme make-return START make-test make-close make-assign make- pair? yes
From FP to OOP. Start with data: class Posn { int x; int y; Posn(int x, int y) { this.x = x; this.y = y; } }
From FP to OOP Start with data: ; A posn is ; (make-posn num num) (define-struct posn (x y)) class Posn { int x; int y; Posn(int x, int y) { this.x = x; this.y = y; 1 From FP to OOP Start with data: ;
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
CPSC W1 University of British Columbia
Definition of Programming Languages CPSC 311 2016W1 University of British Columbia Practice Midterm Eamination 26 October 2016, 19:00 21:00 Joshua Dunfield Student Name: Signature: Student Number: CS userid:
Reminder About Functions
Reminder About Functions (let ((z 17)) (let ((z 3) (a ) (x (lambda (x y) (- x (+ y z))))) (let ((z 0) (a )) (x z a)))) int h, i; void B(int w) { int j, k; i = 2*w; w = w+1; void A(int x, int y) { bool
Interpreter Implementation
Interpreter Implementation l l l The crucial insight to implementing functions is that function names act just like variable names - they are the key into a symbol lookup table. l During function declaration
CS61A Midterm 2 Review (v1.1)
Spring 2006 1 CS61A Midterm 2 Review (v1.1) Basic Info Your login: Your section number: Your TA s name: Midterm 2 is going to be held on Tuesday 7-9p, at 1 Pimentel. What will Scheme print? What will the
Comp 311: Sample Midterm Examination
Comp 311: Sample Midterm Examination October 29, 2007 Name: Id #: Instructions 1. The examination is closed book. If you forget the name for a Scheme operation, make up a name for it and write a brief
Metaprogramming and symbolic execution for detecting runtime errors in Erlang programs
Metaprogramming and symbolic execution for detecting runtime errors in Erlang programs Emanuele De Angelis 1, Fabio Fioravanti 1, Adrián Palacios 2, Alberto Pettorossi 3 and Maurizio Proietti 4 1 University
CMSC 330: Organization of Programming Languages. Operational Semantics
CMSC 330: Organization of Programming Languages Operational Semantics Notes about Project 4, Parts 1 & 2 Still due today (7/2) Will not be graded until 7/11 (along with Part 3) You are strongly encouraged
Understanding Recursion
Understanding Recursion sk, rob and dbtucker (modified for CS 536 by kfisler) 2002-09-20 Writing a Recursive Function Can we write the factorial function in AFunExp? Well, we currently don t have multiplication,
EECS 395 Programming Languages
EECS 395 Programming Languages Winter 2010 Instructor: Robby Findler 1 Course Details http://www.eecs.northwestern.edu/~robby/ courses/395-2010-winter/ (or google findler and follow the links) 2 Programming
EECS 321 Programming Languages
EECS 321 Programming Languages Winter 2010 Instructor: Robby Findler Course Details http://www.eecs.northwestern.edu/~robby/ courses/321-2011-winter/ (or google findler and follow the links) Programming
Functional Programming
Functional Programming CS331 Chapter 14 Functional Programming Original functional language is LISP LISt Processing The list is the fundamental data structure Developed by John McCarthy in the 60 s Used
6.037 Lecture 4. Interpretation. What is an interpreter? Why do we need an interpreter? Stages of an interpreter. Role of each part of the interpreter
6.037 Lecture 4 Interpretation Interpretation Parts of an interpreter Meta-circular Evaluator (Scheme-in-scheme!) A slight variation: dynamic scoping Original material by Eric Grimson Tweaked by Zev Benjamin,
CS 61A Interpreters, Tail Calls, Macros, Streams, Iterators. Spring 2019 Guerrilla Section 5: April 20, Interpreters.
CS 61A Spring 2019 Guerrilla Section 5: April 20, 2019 1 Interpreters 1.1 Determine the number of calls to scheme eval and the number of calls to scheme apply for the following expressions. > (+ 1 2) 3
CS115 - Module 10 - General Trees
Fall 2017 Reminder: if you have not already, ensure you: Read How to Design Programs, Sections 15 and 16. Arithmetic Expressions Recall with binary trees we could represent an expression containing binary
CPSC 311, 2010W1 Midterm Exam #2
CPSC 311, 2010W1 Midterm Exam #2 2010/11/02 Page 1 of 18 CPSC 311, 2010W1 Midterm Exam #2 Name: Q1: 20 Student ID: Q2: 20 Signature (required; indicates agreement with rules below): Q3: 20 Q4: 20 Q5: 20
Environments, Stores, and Interpreters
Environments, Stores, and Interpreters Overview As we study languages we will build small languages that illustrate language features We will use two tools Observational semantic judgements Small interpreters
Principles of Programming Languages
Principles of Programming Languages Lesson 14 Type Checking Collaboration and Management Dana Fisman www.cs.bgu.ac.il/~ppl172 1 Type Checking We return to the issue of type safety we discussed informally,
CS 320 Midterm Exam Solution
Name: BU ID: CS 320 Midterm Exam Solution Fall 2018 Write here the number of the problem you are skipping: You must complete 4 of the 5 problems on this exam for full credit. Each problem is of equal weight.
Getting Started with. Vesna Terzic UC Berkeley. September 2011
Getting Started with OpenSees Vesna Terzic UC Berkeley September 2011 Agenda Introduction ti to OpenSees Introduction to Tcl programming language Demonstration of how to download OpenSees interpreter and
CS 320 Homework One Due 2/5 11:59pm
Name: BU ID (no dashes): CS 320 Homework One Due 2/5 11:59pm Write your answers to the problems in the space indicated. Scan your solution and submit to Gradescope as a PDF file. You will receive an email
(scheme-1) has lambda but NOT define
CS61A Lecture 12 2011-0-11 Colleen Lewis (calc) review (scheme-1) has lambda but NOT define Remember calc-apply? STk> (calc-apply '+ '(1 2 )) 6 STk> (calc-apply '* '(2 4 )) 24 STk> (calc-apply '/ '(10
Structure and Interpretation of Computer Programs
CS 6A Spring 203 Structure and Interpretation of Computer Programs Final Solutions INSTRUCTIONS You have 3 hours to complete the exam. The exam is closed book, closed notes, closed computer, closed calculator,
FP Foundations, Scheme
FP Foundations, Scheme In Text: Chapter 15 1 Functional Programming -- Prelude We have been discussing imperative languages C/C++, Java, Fortran, Pascal etc. are imperative languages Imperative languages
Module 9: Trees. If you have not already, make sure you. Read How to Design Programs Sections 14, 15, CS 115 Module 9: Trees
Module 9: Trees If you have not already, make sure you Read How to Design Programs Sections 14, 15, 16. 1 CS 115 Module 9: Trees Mathematical Expressions We are going to discuss how to represent mathematical
Programming Languages: Application and Interpretation
Programming Languages: Application and Interpretation Version Second Edition Shriram Krishnamurthi April 14, 2017 1 Contents 1 Introduction 7 1.1 Our Philosophy............................. 7 1.2 The Structure
Parsing II Top-down parsing. Comp 412
COMP 412 FALL 2018 Parsing II Top-down parsing Comp 412 source code IR Front End Optimizer Back End IR target code Copyright 2018, Keith D. Cooper & Linda Torczon, all rights reserved. Students enrolled
fjyswan Dr. Philip Cannata 1
fjyswan Dr. Philip Cannata 1 10 High Level Languages This Course Jython in Java Java (Object Oriented) Relation ASP RDF (Horn Clause Deduction, Semantic Web) Dr. Philip Cannata 2 Dr. Philip Cannata 3 fjyswan
Fall 2012 CS345 Project Requirements and Suggestions (Version 4)
Fall 2012 CS345 Project Requirements and Suggestions (Version 4) Languages developed or modified for your project should have the following properties unless there is a good reason not to (e.g., you re
Principles of Programming Languages
Principles of Programming Languages Slides by Dana Fisman based on book by Mira Balaban and lecuture notes by Michael Elhadad Lesson 15 Type Inference Collaboration and Management Dana Fisman www.cs.bgu.ac.il/~ppl172
Space War Class Diagram. Elements of OOP. How to design interactions between objects. Space War Class Diagram with Inheritance
Elements of OOP Object Smart data structure Set of state variables Set of methods for manipulating state variables Class: Specifies the common behavior of entities Instance: A particular object or entity
CS115 - Module 8 - Binary trees
Fall 2017 Reminder: if you have not already, ensure you: Read How to Design Programs, Section 14. Binary arithmetic expressions Operators such as +,,, and take two arguments, so we call them binary operators.
Racket: Modules, Contracts, Languages
Racket: Modules, Contracts, Languages Advanced Functional Programming Jean-Noël Monette November 2013 1 Today Modules are the way to structure larger programs in smaller pieces. Modules can import and
Object-Oriented Programming Languages: Application and Interpretation
Object-Oriented Programming Languages: Application and Interpretation Éric Tanter June 15, 2018 last updated: Friday, June 15th, 2018 Copyright 2010-2018 by Éric Tanter The electronic version of this work
Printed by Zachary Tatlock Nov 04, 16 8:59 Page 1/9. (** Call By Value << v ::= \ x. e e1 > e1 e1 e2 > e1 e2 e2 > e2 v e2 > v e2
Nov 04, 16 8:59 Page 1/9 Require Import List. Require Import String. Import ListNotations. Open Scope string_scope. Require Import StructTactics. Inductive expr : Set := Var : string > expr Lam : string
EECS 321 Programming Languages
EECS 321 Programming Languages Winter 2015 Instructor: Robby Findler 1 Course Details http://www.eecs.northwestern.edu/~robby/ courses/321-2015-winter/ (or google findler and follow the links) 2 TA & Office
Decision Trees. This week: Next week: constructing DT. Pruning DT. Ensemble methods. Greedy Algorithm Potential Function.
Decision Trees This week: constructing DT Greedy Algorithm Potential Function upper bounds the error Pruning DT Next week: Ensemble methods Random Forest 2 Decision Trees - Boolean x 0 + x 6 0 + - 3 Decision
Section 4.3: Derivatives and the Shapes of Curves
1 Section 4.: Derivatives and the Shapes of Curves Practice HW from Stewart Textbook (not to hand in) p. 86 # 1,, 7, 9, 11, 19, 1,, 5 odd The Mean Value Theorem If f is a continuous function on the closed
CMSC 330: Organization of Programming Languages
CMSC 330: Organization of Programming Languages Operational Semantics CMSC 330 Summer 2018 1 Formal Semantics of a Prog. Lang. Mathematical description of the meaning of programs written in that language
Programming Languages
CSE 130 : Fall 2009 Programming Languages Lecture 13: Whats in a name? Ranjit Jhala UC San Diego f = open( foo.txt, read ) f.readlines() for l in f.readlines(): f.close ou now know enough to do PA5
1 Lexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2013 Handout Decaf Language Thursday, Feb 7 The project for the course is to write a compiler
CS558 Programming Languages
CS558 Programming Languages Fall 2016 Lecture 3a Andrew Tolmach Portland State University 1994-2016 Formal Semantics Goal: rigorous and unambiguous definition in terms of a wellunderstood formalism (e.g.
Lexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Fall 2005 Handout 6 Decaf Language Wednesday, September 7 The project for the course is to write a
JavaScript: Features, Trends, and Static Analysis
JavaScript: Features, Trends, and Static Analysis Joonwon Choi ROPAS Show & Tell 01/25/2013 1 Contents What is JavaScript? Features Trends Static Analysis Conclusion & Future Works 2 What is JavaScript?
Scheme-Style Macros: Patterns and Lexical Scope
Scheme-Style Macros: Patterns and Lexical Scope Matthew Flatt University of Utah 1 Why Macros? Language designers have to stop somewhere (544 pages) No language can provide every possible useful construct
Chapter 3: Describing Syntax and Semantics. Introduction Formal methods of describing syntax (BNF)
Chapter 3: Describing Syntax and Semantics Introduction Formal methods of describing syntax (BNF) We can analyze syntax of a computer program on two levels: 1. Lexical level 2. Syntactic level Lexical
Compilers Course Lecture 4: Context Free Grammars
Compilers Course Lecture 4: Context Free Grammars Example: attempt to define simple arithmetic expressions using named regular expressions: num = [0-9]+ sum = expr "+" expr expr = "(" sum ")" num Appears
WCCP Configuration Mode Commands
WCCP Configuration Mode Commands To configure the Web Cache Coordination Protocol (WCCP) Version 2 TCP promiscuous mode service, use the wccp tcp-promiscuous service-pair global configuration command.
Lexical Considerations
Massachusetts Institute of Technology Department of Electrical Engineering and Computer Science 6.035, Spring 2010 Handout Decaf Language Tuesday, Feb 2 The project for the course is to write a compiler
Finite Math Linear Programming 1 May / 7
Linear Programming Finite Math 1 May 2017 Finite Math Linear Programming 1 May 2017 1 / 7 General Description of Linear Programming Finite Math Linear Programming 1 May 2017 2 / 7 General Description of
Syntax Analysis, III Comp 412
COMP 412 FALL 2017 Syntax Analysis, III Comp 412 source code IR Front End Optimizer Back End IR target code Copyright 2017, Keith D. Cooper & Linda Torczon, all rights reserved. Students enrolled in Comp
6.037 Lecture 7B. Scheme Variants Normal Order Lazy Evaluation Streams
6.037 Lecture 7B Scheme Variants Normal Order Lazy Evaluation Streams Edited by Mike Phillips & Ben Vandiver Original Material by Eric Grimson & Duane Boning Further Variations on a Scheme Beyond Scheme
6.184 Lecture 4. Interpretation. Tweaked by Ben Vandiver Compiled by Mike Phillips Original material by Eric Grimson
6.184 Lecture 4 Interpretation Tweaked by Ben Vandiver Compiled by Mike Phillips Original material by Eric Grimson 1 Interpretation Parts of an interpreter Arithmetic calculator
Shell Programming (bash)
Shell Programming Shell Programming (bash) Commands run from a file in a subshell A great way to automate a repeated sequence of commands. File starts with #!/bin/bash absolute path to the shell program
Streams, Delayed Evaluation and a Normal Order Interpreter. CS 550 Programming Languages Jeremy Johnson
Streams, Delayed Evaluation and a Normal Order Interpreter CS 550 Programming Languages Jeremy Johnson 1 Theme This lecture discusses the stream model of computation and an efficient method of implementation
Sometimes an ambiguous grammar can be rewritten to eliminate the ambiguity.
Eliminating Ambiguity Sometimes an ambiguous grammar can be rewritten to eliminate the ambiguity. Example: consider the following grammar stat if expr then stat if expr then stat else stat other One can
CSc 520 Principles of Programming Languages
CSc 520 Principles of Programming Languages 9: Scheme Metacircular Interpretation Christian Collberg collberg@cs.arizona.edu Department of Computer Science University of Arizona Copyright c 2005 Christian
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
User-defined Functions. Conditional Expressions in Scheme
User-defined Functions The list (lambda (args (body s to a function with (args as its argument list and (body as the function body. No quotes are needed for (args or (body. (lambda (x (+ x 1 s to the increment
CSc 372. Comparative Programming Languages. 36 : Scheme Conditional Expressions. Department of Computer Science University of Arizona
1/26 CSc 372 Comparative Programming Languages 36 : Scheme Conditional Expressions Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2013 Christian Collberg 2/26 Comparison
Template Haskell based implementation of printf
Lecture 19 Template Haskell based implementation of printf In the last lecture we saw a type class based solution to create functions that take variable number of arguments. Here we give a template haskell
Building up a language SICP Variations on a Scheme. Meval. The Core Evaluator. Eval. Apply. 2. syntax procedures. 1.
6.001 SICP Variations on a Scheme Scheme Evaluator A Grand Tour Techniques for language design: Interpretation: eval/appl Semantics vs. snta Sntactic transformations Building up a language... 3. 1. eval/appl
TAIL RECURSION, SCOPE, AND PROJECT 4 11
TAIL RECURSION, SCOPE, AND PROJECT 4 11 COMPUTER SCIENCE 61A Noveber 12, 2012 1 Tail Recursion Today we will look at Tail Recursion and Tail Call Optimizations in Scheme, and how they relate to iteration
COMP520 - GoLite Type Checking Specification
COMP520 - GoLite Type Checking Specification Vincent Foley February 26, 2015 1 Declarations Declarations are the primary means of introducing new identifiers in the symbol table. In Go, top-level declarations
Visualization of Biomolecular Structures
T H E U N I V E R S I T Y of T E X A S H E A L T H S C I E N C E C E N T E R A T H O U S T O N S C H O O L of H E A L T H I N F O R M A T I O N S C I E N C E S Visualization of Biomolecular Structures