Konzepte von Programmiersprachen
|
|
|
- Aubrie Crawford
- 6 years ago
- Views:
Transcription
1 Konzepte von Programmiersprachen Chapter 5: Continuation-Passing Interpreters Stefan Wehr Universität Freiburg 8. Juni 2009 Konzepte von Programmiersprachen 1 / 43
2 Motivation Continuations: abstraction of the notion of control context (Environments: abstraction of data contexts) Support for control operators: Exceptions Threads Coroutines call/cc Introducing continuations is a common transformation in compilers: Makes control-flow explicit Introduces names for intermediate results Konzepte von Programmiersprachen 2 / 43
3 What is a control context? Intuition (not a formal definition) the rest of the program things that happen after evaluating the current expression Konzepte von Programmiersprachen 3 / 43
4 Outline Rewrite interpreter for the LETREC language in continuation-passing style (CPS): make control context explicit by passing around a continuation Use a trick that allows our CPS interpreter to be written in languages without support for tail calls Perform a translation of our CPS interpreter to use jumps instead of procedure calls Use the CPS interpreter to implement exceptions (Use the CPS interpreter to implement threads) Konzepte von Programmiersprachen 4 / 43
5 A Continuation-Passing Interpreter Design principles for the CPS (continuation-passing style) interpreter: No call to value-of grows the control context of the underlying scheme interpreter all calls to value-of must be tail calls Make the control context explicit using continuations Konzepte von Programmiersprachen 5 / 43
6 What s a tail call, anyway? Definition A procedure call is in tail position if it is the last operation of the calling procedure. A tail call is a procedure call in tail position. A tail-recursive procedure is a procedure whose recursive calls are all tail calls. Tail calls give raise the tail call optimization: Do not push the stack frame of the procedure being called on the stack frame of the calling procedure. Instead, pop the stack frame of the calling procedure before performing the tail call. Tail-recursive procedures under tail call optimization require only constant stack space. Konzepte von Programmiersprachen 6 / 43
7 Recursive definition of the factorial function (define fact (lambda (n) (if (zero? n) 1 (* n (fact (- n 1)))))) Calculating with fact: (fact 3) = (* 3 (fact 2)) = (* 3 (* 2 (fact 1))) = (* 3 (* 2 (* 1 (fact 0)))) = (* 3 (* 2 (* 1 1))) = (* 3 (* 2 1)) = (* 3 2) = 6 Konzepte von Programmiersprachen 7 / 43
8 Tail recursive definition of the factorial function (define fact-iter (lambda (n) (fact-iter-acc n 1))) (define fact-iter-acc (lambda (n a) (if (zero? n) a (fact-iter-acc (- n 1) (* n a))))) Calculating with fact-iter: (fact-iter 3) = (fact-iter-acc 3 1) = (fact-iter-acc 2 3) = (fact-iter-acc 1 6) = (fact-iter-acc 0 6) = 6 Konzepte von Programmiersprachen 8 / 43
9 What s a continuation, anyway? Definition The continuation of an expression represents a procedure that takes the result of the expression and completes the computation. An interface for continuations FinalAnswer = ExpVal apply-cont : Cont * ExpVal -> FinalAnswer Konzepte von Programmiersprachen 9 / 43
10 CPS interpreter: value-of-program ;; value-of-program : Program -> FinalAnswer (define value-of-program (lambda (pgm) (cases program pgm (a-program (exp1) (value-of/k exp1 (init-env) (end-cont)))))) ;; value-of/k : Exp * Env * Cont -> FinalAnswer Specification of apply-cont (partial) (apply-cont (end-cont) val) = (begin (eopl:printf "End of computation.~%") val)) Konzepte von Programmiersprachen 10 / 43
11 CPS interpreter: value-of/k (1/6) ;; value-of/k : Exp * Env * Cont -> FinalAnswer (define value-of/k (lambda (exp env cont) (cases expression exp (const-exp (num) (apply-cont cont (num-val num))) (var-exp (var) (apply-cont cont (apply-env env var))) (proc-exp (var body) (apply-cont cont (proc-val (procedure var body env)))) (letrec-exp (p-name b-var p-body letrec-body) (value-of/k letrec-body (extend-env-rec p-name b-var p-body env) cont))... Konzepte von Programmiersprachen 11 / 43
12 CPS interpreter: value-of/k (2/6) (zero?-exp (exp1) (value-of/k exp1 env (zero1-cont cont))) Specification of apply-cont (continued, still partial) (apply-cont (zero1-cont cont) val) = (apply-cont cont (bool-val (zero? (expval->num val)))) Konzepte von Programmiersprachen 12 / 43
13 CPS interpreter: value-of/k (3/6) (let-exp (var exp1 body) (value-of/k exp1 env (let-exp-cont var body env cont))) Specification of apply-cont (continued, still partial) (apply-cont (let-exp-cont var body env cont) val) = (value-of/k body (extend-env var val env) cont) Konzepte von Programmiersprachen 13 / 43
14 CPS interpreter: value-of/k (4/6) (if-exp (exp1 exp2 exp3) (value-of/k exp1 env (if-test-cont exp2 exp3 env cont))) Specification of apply-cont (continued, still partial) (apply-cont (if-test-cont exp2 exp3 env cont) val) = (if (expval->bool val) (value-of/k exp2 env cont) (value-of/k exp3 env cont)) Konzepte von Programmiersprachen 14 / 43
15 CPS interpreter: value-of/k (5/6) (diff-exp (exp1 exp2) (value-of/k exp1 env (diff1-cont exp2 env cont))) Specification of apply-cont (continued, still partial) (apply-cont (diff1-cont exp2 env cont) val1) = (value-of/k exp2 env (diff2-cont val1 cont)) (apply-cont (diff2-cont val1 cont) val2) = (let ((num1 (expval->num val1)) (num2 (expval->num val2))) (apply-cont cont (num-val (- num1 num2)))) Konzepte von Programmiersprachen 15 / 43
16 CPS interpreter: value-of/k (6/6) (call-exp (rator rand) (value-of/k rator env (rator-cont rand env cont))) ))) ;; end definition of value-of/k Specification of apply-cont (continued) (apply-cont (rator-cont rand env cont) val1) = (value-of/k rand env (rand-cont val1 cont)) (apply-cont (rand-cont val1 cont) val2) = (let ((proc1 (expval->proc val1))) (apply-procedure/k proc1 val2 cont)) Konzepte von Programmiersprachen 16 / 43
17 CPS interpreter: apply-procedure/k ;; apply-procedure/k : Proc * ExpVal * Cont ;; -> FinalAnswer (define apply-procedure/k (lambda (proc1 val cont) (cases proc proc1 (procedure (var body saved-env) (value-of/k body (extend-env var val saved-env) cont))))) Konzepte von Programmiersprachen 17 / 43
18 Examples 1. (value-of/k <<-(-(44,11),3)>> ρ 0 #(struct:end-cont)) 2. (value-of/k <<(exp1 exp2)>> ρ 1 cont1) see blackboard Konzepte von Programmiersprachen 18 / 43
19 Implementing the specification for continuations Two options: Procedural representation Data structure representation Konzepte von Programmiersprachen 19 / 43
20 Procedural representation ;; Cont = ExpVal -> FinalAnswer ;; end-cont : () -> Cont (define end-cont (lambda () (lambda (val) (begin (eopl:printf "End of computation.~%") val)))) ;; zero1-cont : Cont -> Cont (define zero1-cont (lambda (cont) (lambda (val) (apply-cont cont (bool-val (zero? (expval->num val)))))))... ;; apply-cont : Cont * ExpVal -> FinalAnswer (define apply-cont (lambda (cont v) (cont v))) Konzepte von Programmiersprachen 20 / 43
21 Data structure representation (define-datatype continuation continuation? (end-cont) (zero1-cont (cont continuation?))... ) ;; apply-cont : Cont * ExpVal -> FinalAnswer (define apply-cont (lambda (cont val) (cases continuation cont (end-cont () (begin (eopl:printf "End of computation.~%") val)) (zero1-cont (saved-cont) (apply-cont saved-cont (bool-val (zero? (expval->num val)))))... ))) Konzepte von Programmiersprachen 21 / 43
22 A trampolined CPS interpreter Problems when porting the CPS interpreter to a procedural language: No first-class functions Solution: use data structure representation for continuations No support for tail calls danger of stack overflow because procedure calls only return when the CPS interpreter ends Solution: Trampolined interpreter (explained next) Konzepte von Programmiersprachen 22 / 43
23 Skeleton of our CPS interpreter ;; value-of-program : Program -> FinalAnswer (define value-of-program (... (value-of/k...)...)) ;; value-of/k : Exp * Env * Cont -> FinalAnswer (define value-of/k (... (value-of/k...) (apply-cont...)...)) ;; apply-cont : Cont * ExpVal -> FinalAnswer ;; (data structure representation) (define apply-cont (... (value-of/k...) (apply-cont...) (apply-procedure/k...)...)) ;; apply-procedure/k : Proc * ExpVal * Cont ;; -> FinalAnswer (define apply-procedure/k (... (value-of/k...)...)) Konzepte von Programmiersprachen 23 / 43
24 Example (CPS interpreter, tail calls) value-of-program Konzepte von Programmiersprachen 24 / 43
25 Example (CPS interpreter, tail calls) value-of/k Konzepte von Programmiersprachen 24 / 43
26 Example (CPS interpreter, tail calls) apply-cont Konzepte von Programmiersprachen 24 / 43
27 Example (CPS interpreter, tail calls) apply-procedure/k Konzepte von Programmiersprachen 24 / 43
28 Example (CPS interpreter, tail calls) value-of/k Konzepte von Programmiersprachen 24 / 43
29 Example (CPS interpreter, tail calls) apply-cont Konzepte von Programmiersprachen 24 / 43
30 Example (CPS interpreter, tail calls) apply-procedure/k Konzepte von Programmiersprachen 24 / 43
31 Example (CPS interpreter, tail calls) value-of/k Konzepte von Programmiersprachen 24 / 43
32 Example (CPS interpreter, tail calls)... Konzepte von Programmiersprachen 24 / 43
33 Example (CPS interpreter, no tail calls) value-of-program Konzepte von Programmiersprachen 25 / 43
34 Example (CPS interpreter, no tail calls) value-ok/k value-of-program Konzepte von Programmiersprachen 25 / 43
35 Example (CPS interpreter, no tail calls) apply-cont value-ok/k value-of-program Konzepte von Programmiersprachen 25 / 43
36 Example (CPS interpreter, no tail calls) apply-procedure/k apply-cont value-ok/k value-of-program Konzepte von Programmiersprachen 25 / 43
37 Example (CPS interpreter, no tail calls) value-ok/k apply-procedure/k apply-cont value-ok/k value-of-program Konzepte von Programmiersprachen 25 / 43
38 Example (CPS interpreter, no tail calls) apply-cont value-ok/k apply-procedure/k apply-cont value-ok/k value-of-program Konzepte von Programmiersprachen 25 / 43
39 Example (CPS interpreter, no tail calls) apply-procedure/k apply-cont value-ok/k apply-procedure/k apply-cont value-ok/k value-of-program Konzepte von Programmiersprachen 25 / 43
40 Example (CPS interpreter, no tail calls) value-of/k apply-procedure/k apply-cont value-ok/k apply-procedure/k apply-cont value-ok/k value-of-program Konzepte von Programmiersprachen 25 / 43
41 Example (CPS interpreter, no tail calls)... value-of/k apply-procedure/k apply-cont value-ok/k apply-procedure/k apply-cont value-ok/k value-of-program Konzepte von Programmiersprachen 25 / 43
42 Trampolined interpreter Observation: An unbounded chain of procedure calls always involves calls of apply-procedure/k. Break the chain inside apply-procedure/k: apply-procedure/k should not call value-of/k directly apply-procedure/k returns a zero-argument procedure that calls value-of/k A trampoline procedure then invokes this zero-argument procedure to keep the system going. Konzepte von Programmiersprachen 26 / 43
43 Example (Trampolined CPS interpreter, no tail calls) value-of-program Konzepte von Programmiersprachen 27 / 43
44 Example (Trampolined CPS interpreter, no tail calls) value-ok/k value-of-program Konzepte von Programmiersprachen 27 / 43
45 Example (Trampolined CPS interpreter, no tail calls) apply-cont value-ok/k value-of-program Konzepte von Programmiersprachen 27 / 43
46 Example (Trampolined CPS interpreter, no tail calls) apply-procedure/k apply-cont value-ok/k value-of-program Konzepte von Programmiersprachen 27 / 43
47 Example (Trampolined CPS interpreter, no tail calls) trampoline value-of-program Konzepte von Programmiersprachen 27 / 43
48 Example (Trampolined CPS interpreter, no tail calls) value-of/k trampoline value-of-program Konzepte von Programmiersprachen 27 / 43
49 Example (Trampolined CPS interpreter, no tail calls) apply-cont value-of/k trampoline value-of-program Konzepte von Programmiersprachen 27 / 43
50 Example (Trampolined CPS interpreter, no tail calls) apply-procedure/k apply-cont value-of/k trampoline value-of-program Konzepte von Programmiersprachen 27 / 43
51 Example (Trampolined CPS interpreter, no tail calls) trampoline value-of-program Konzepte von Programmiersprachen 27 / 43
52 Example (Trampolined CPS interpreter, no tail calls)... trampoline value-of-program Konzepte von Programmiersprachen 27 / 43
53 Skeleton of the trampolined CPS interpreter ;; value-of-program : Program -> FinalAnswer (define value-of-program (... (trampoline (value-of/k...))...)) ;; value-of/k : Exp * Env * Cont -> Bounce (define value-of/k (... (value-of/k...) (apply-cont...)...)) ;; apply-cont : Cont * ExpVal -> Bounce ;; (data structure representation) (define apply-cont (... (value-of/k...) (apply-cont...) (apply-procedure/k...)...)) ;; apply-procedure/k : Proc * ExpVal * Cont -> Bounce (define apply-procedure/k (... (lambda () (value-of/k...))...)) Konzepte von Programmiersprachen 28 / 43
54 trampoline ;; trampoline : Bounce -> FinalAnswer (define trampoline (lambda (bounce) (if (expval? bounce) bounce (trampoline (bounce))))) Konzepte von Programmiersprachen 29 / 43
55 trampoline ;; trampoline : Bounce -> FinalAnswer (define trampoline (lambda (bounce) (if (expval? bounce) bounce (trampoline (bounce))))) Bounce = ExpVal (() Bounce) Konzepte von Programmiersprachen 29 / 43
56 An interpreter with jumps Goal: Get rid off procedure calls in the interpreter, use jumps instead Insight I: Use shared variables instead of procedure parameters Insight II: A zero-argument tail call is the same as a jump Konzepte von Programmiersprachen 30 / 43
57 Example with procedure parameters letrec even(x) = if zero?(x) then 1 else (odd -(x,1)) odd(x) = if zero?(x) then 0 else (even -(x,1)) in (odd 13) Konzepte von Programmiersprachen 31 / 43
58 Example without procedure parameters let x = 0 in letrec even() = if zero?(x) then 1 else begin set x = -(x,1); (odd) end odd() = if zero?(x) then 0 else begin set x = -(x,1); (even) end in begin set x = 13; (odd) end Konzepte von Programmiersprachen 32 / 43
59 Example with jumps x = 13; goto odd; even: if (x == 0) { return 1; } else { x = x-1; goto odd; } odd: if (x == 0) { return 0; } else { x = x-1; goto even; } Konzepte von Programmiersprachen 33 / 43
60 Skeleton of our CPS interpreter ;; value-of-program : Program -> FinalAnswer (define value-of-program (... (value-of/k...)...)) ;; value-of/k : Exp * Env * Cont -> FinalAnswer (define value-of/k (... (value-of/k...) (apply-cont...)...)) ;; apply-cont : Cont * ExpVal -> FinalAnswer ;; (data structure representation) (define apply-cont (... (value-of/k...) (apply-cont...) (apply-procedure/k...)...)) ;; apply-procedure/k : Proc * ExpVal * Cont ;; -> FinalAnswer (define apply-procedure/k (... (value-of/k...)...)) Konzepte von Programmiersprachen 34 / 43
61 Introducing registers Relevant procedures of the CPS interpreter: (value-of/k exp env cont) (apply-cont cont val) (apply-procedure/k proc val cont) We need five global registers: reg_exp reg_env reg_cont reg_val reg_proc Konzepte von Programmiersprachen 35 / 43
62 Rewriting the interpreter Systematically replace fragments such as (define value-of/k (lambda (exp env cont) (cases expression exp (const-exp (num) (apply-cont cont (num-val num)))...))) by (define value-of/k (lambda (exp env cont) (cases expression exp (const-exp (num) (set! cont cont) (set! val (num-val num)) (apply-cont))...))) Konzepte von Programmiersprachen 36 / 43
63 Things to watch out for Register stay often unchanged from one procedure call to another omit redundant assignments such as (set! reg_cont reg_cont) Local bindings must not shadow global registers the prefix reg_ for register names takes care of that Attention is needed if the same registers is used more than once in a procedure call does not occur in our example Konzepte von Programmiersprachen 37 / 43
64 Skeleton of the interpreter with jumps (1/2) ;; reg_exp : Exp (define reg_exp uninitialized) ;; reg_env : Env (define reg_env uninitialized) ;; reg_cont : Cont (define reg_cont uninitialized) ;; reg_val : ExpVal (define reg_val uninitialized) ;; reg_proc : Proc (define reg_proc uninitialized) Konzepte von Programmiersprachen 38 / 43
65 Skeleton of the interpreter with jumps (2/2) ;; value-of-program : Program -> FinalAnswer (define value-of-program (... (value-of/k)...)) ;; value-of/k : () -> FinalAnswer (define value-of/k (... (value-of/k) (apply-cont)...)) ;; apply-cont : () -> FinalAnswer (define apply-cont (... (value-of/k) (apply-cont) (apply-procedure/k)...)) ;; apply-procedure/k : () -> FinalAnswer (define apply-procedure/k (... (value-of/k)...)) Konzepte von Programmiersprachen 39 / 43
66 Exceptions Two new productions: Expression ::= try Expression catch (Identifier) Expression try-exp (exp1 var handler-exp) Expression ::= raise Expression raise-exp (exp) Semantics: raise e evaluates e and then raises an exception with that value. try e 1 catch (x) e 2 first evaluates e 1. If no exception occurs while evaluating e 1, then the result of e 1 is the result of the whole expression. If an exception occurs while evaluating e 1, the exception value is bound to x and the handler e 2 is evaluated. Konzepte von Programmiersprachen 40 / 43
67 Implementing exceptions with continuations ;; value-of/k : Exp * Env * Cont -> FinalAnswer (define value-of/k (lambda (exp env cont) (cases expression exp... (try-exp (exp1 var handler-exp) (value-of/k exp1 env (try-cont var handler-exp env cont))) (raise-exp (exp1) (value-of/k exp1 env (raise1-cont cont)))))) Konzepte von Programmiersprachen 41 / 43
68 Specification of apply-cont (extended) (apply-cont (try-cont var handler-exp env cont) val) = (apply-cont cont val) (apply-cont (raise1-cont cont) val) = (apply-handler val cont) Konzepte von Programmiersprachen 42 / 43
69 apply-handler (apply-handler val cont) searches for the closest exception handler in cont and applies it to val ;; apply-handler : ExpVal * Cont -> FinalAnswer (define apply-handler (lambda (val cont) (cases continuation cont (try-cont (var handler-exp saved-env saved-cont) (value-of/k handler-exp (extend-env var val saved-env) saved-cont)) (end-cont () (report-uncaught-exception)) (diff1-cont (exp2 saved-env saved-cont) (apply-handler val saved-cont))...))) Note: The implementation relies on the data structure representation of continuations. It is also possible to implement apply-handler with a procedural representation of continuations (see EOPL, exercise 5.41). Konzepte von Programmiersprachen 43 / 43
Procedures. EOPL3: Section 3.3 PROC and App B: SLLGEN
Procedures EOPL3: Section 3.3 PROC and App B: SLLGEN The PROC language Expression ::= proc (Identifier) Expression AST: proc-exp (var body) Expression ::= (Expression Expression) AST: call-exp (rator rand)
Lecture 3: Expressions
CS 7400 September 23 30, 2009 Dr. Wand Readings: EOPL3, Secs. 3.1 3.5 Lecture 3: Expressions Key Concepts: syntax and semantics expressed and denoted values expressions environment specifying the behavior
Computer Science 21b (Spring Term, 2015) Structure and Interpretation of Computer Programs. Lexical addressing
Computer Science 21b (Spring Term, 2015) Structure and Interpretation of Computer Programs Lexical addressing The difference between a interpreter and a compiler is really two points on a spectrum of possible
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
Homework 3 COSE212, Fall 2018
Homework 3 COSE212, Fall 2018 Hakjoo Oh Due: 10/28, 24:00 Problem 1 (100pts) Let us design and implement a programming language called ML. ML is a small yet Turing-complete functional language that supports
Continuations and Continuation-Passing Style
Continuations and Continuation-Passing Style Lecture 4 CS 390 1/16/08 Goal Weʼre interested in understanding how to represent the state of a co-routine Insight into what a thread really means How fundamental
1. For every evaluation of a variable var, the variable is bound.
7 Types We ve seen how we can use interpreters to model the run-time behavior of programs. Now we d like to use the same technology to analyze or predict the behavior of programs without running them.
Deferred operations. Continuations Structure and Interpretation of Computer Programs. Tail recursion in action.
Deferred operations Continuations 6.037 - Structure and Interpretation of Computer Programs Mike Phillips (define the-cons (cons 1 #f)) (set-cdr! the-cons the-cons) (define (run-in-circles l) (+
Functional Programming. Pure Functional Programming
Functional Programming Pure Functional Programming Computation is largely performed by applying functions to values. The value of an expression depends only on the values of its sub-expressions (if any).
UNIT 3
UNIT 3 Presentation Outline Sequence control with expressions Conditional Statements, Loops Exception Handling Subprogram definition and activation Simple and Recursive Subprogram Subprogram Environment
CS 342 Lecture 8 Data Abstraction By: Hridesh Rajan
CS 342 Lecture 8 Data Abstraction By: Hridesh Rajan 1 Com S 342 so far So far we have studied: Language design goals, Basic functional programming, Flat recursion over lists, Notion of Scheme procedures
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.
Register Machines. Connecting evaluators to low level machine code
Register Machines Connecting evaluators to low level machine code 1 Plan Design a central processing unit (CPU) from: wires logic (networks of AND gates, OR gates, etc) registers control sequencer Our
Control in Sequential Languages
CS 242 2012 Control in Sequential Languages Reading: Chapter 8, Sections 8.1 8.3 (only) Section 7.3 of The Haskell 98 Report, Exception Handling in the I/O Monad, http://www.haskell.org/onlinelibrary/io-13.html
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,
9 Objects and Classes
9 Objects and Classes Many programming tasks require the program to manage some piece of state through an interface. For example, a file system has internal state, but we access and modify that state only
CVO103: Programming Languages. Lecture 5 Design and Implementation of PLs (1) Expressions
CVO103: Programming Languages Lecture 5 Design and Implementation of PLs (1) Expressions Hakjoo Oh 2018 Spring Hakjoo Oh CVO103 2018 Spring, Lecture 5 April 3, 2018 1 / 23 Plan Part 1 (Preliminaries):
G Programming Languages - Fall 2012
G22.2110-003 Programming Languages - Fall 2012 Lecture 4 Thomas Wies New York University Review Last week Control Structures Selection Loops Adding Invariants Outline Subprograms Calling Sequences Parameter
Tail calls. Tail calls. (and their elimination) Functional loops. The problem. Advanced Compiler Construction Michel Schinz
Tail calls Advanced Compiler Construction Michel Schinz 26 4 2 Tail calls (and their elimination) 2 Functional loops The problem Several functional programming languages do not have an explicit looping
Tail calls. Advanced Compiler Construction Michel Schinz
Tail calls Advanced Compiler Construction Michel Schinz 2016 04 21 Tail calls (and their elimination) Functional loops Several functional programming languages do not have an explicit looping statement.
An Explicit-Continuation Metacircular Evaluator
Computer Science (1)21b (Spring Term, 2018) Structure and Interpretation of Computer Programs An Explicit-Continuation Metacircular Evaluator The vanilla metacircular evaluator gives a lot of information
First-class continuations. call/cc, stack-passing CEK machines
First-class continuations call/cc, stack-passing CEK machines But first Assignment 2 e ::= (letrec* ([x e]...) e) (letrec ([x e]...) e) (let* ([x e]...) e) (let ([x e]...) e) (let x ([x e]...) e) (lambda
regsim.scm ~/umb/cs450/ch5.base/ 1 11/11/13
1 File: regsim.scm Register machine simulator from section 5.2 of STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS This file can be loaded into Scheme as a whole. Then you can define and simulate machines
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
CS422 - Programming Language Design
1 CS422 - Programming Language Design Continuation-Passing Style (CPS) Transformation Grigore Roşu Department of Computer Science University of Illinois at Urbana-Champaign 2 On Data Versus Control Context
Lecture 09: Data Abstraction ++ Parsing is the process of translating a sequence of characters (a string) into an abstract syntax tree.
Lecture 09: Data Abstraction ++ Parsing Parsing is the process of translating a sequence of characters (a string) into an abstract syntax tree. program text Parser AST Processor Compilers (and some interpreters)
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
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,
Compilers: The goal. Safe. e : ASM
Compilers: The goal What s our goal with compilers? Take a high level language, turn it into a low level language In a semantics preserving way. e : ML Safe e : ASM 1 Compilers: The goal What s our goal
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
Certified Memory Usage Analysis
Certified Memory Usage Analysis David Cachera, Thomas Jensen, David Pichardie, Gerardo Schneider IRISA, ENS Cachan Bretagne, France Context Embedded devices (smart cards, mobile phones) memory is limited
Optimizing Scheme, part I
Optimizing Scheme, part I cons should not cons its arguments, part I a Lazy Alloc is a Smart Alloc Alex Gal COMP 621 cancelled stack-storage optimization for short-lived data a one slide summary most object
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
Principles of Programming Languages
Principles of Programming Languages Lecture 08 Control Semantics & Continuations Semantics of Control Flow Sequencers: commands that cause control transfers:! goto! return! exit! break! continue! resultis
CSE341, Spring 2013, Final Examination June 13, 2013
CSE341, Spring 2013, Final Examination June 13, 2013 Please do not turn the page until 8:30. Rules: The exam is closed-book, closed-note, except for both sides of one 8.5x11in piece of paper. Please stop
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 9/18/17
Code example: sfact SICP Explicit-control evaluator. Example register machine: instructions. Goal: a tail-recursive evaluator.
6.001 SICP Explicit-control evaluator Big ideas: how to connect evaluator to machine instructions how to achieve tail recursion Obfuscation: tightly optimized instruction sequence Background eval-dispatch
Lecture08: Scope and Lexical Address
Lecture08: Scope and Lexical Address Free and Bound Variables (EOPL 1.3.1) Given an expression E, does a particular variable reference x appear free or bound in that expression? Definition: A variable
The role of semantic analysis in a compiler
Semantic Analysis Outline 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
n What is its running time? 9/18/17 2 n poor_rev [1,2,3] = n (poor_rev [1] = n ((poor_rev [1] =
![n What is its running time? 9/18/17 2 n poor_rev [1,2,3] = n (poor_rev [1] = n ((poor_rev [1] =](/thumbs/92/108912101.jpg "n What is its running time? 9/18/17 2 n poor_rev [1,2,3] = n (poor_rev [1] = n ((poor_rev [1] =")
Recall Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha
An Elegant Weapon for a More Civilized Age
An Elegant Weapon for a More Civilized Age Solving an Easy Problem What are the input types? What is the output type? Give example input/output pairs Which input represents the domain of the recursion,
References and Exceptions. CS 565 Lecture 14 4/1/08
References and Exceptions CS 565 Lecture 14 4/1/08 References In most languages, variables are mutable: it serves as a name for a location the contents of the location can be overwritten, and still be
INF 212 ANALYSIS OF PROG. LANGS FUNCTION COMPOSITION. Instructors: Crista Lopes Copyright Instructors.
INF 212 ANALYSIS OF PROG. LANGS FUNCTION COMPOSITION Instructors: Crista Lopes Copyright Instructors. Topics Recursion Higher-order functions Continuation-Passing Style Monads (take 1) Identity Monad Maybe
Lecture 5: Declarative Programming. The Declarative Kernel Language Machine. September 12th, 2011
Lecture 5: Declarative Programming. The Declarative Kernel Language Machine September 12th, 2011 1 Lecture Outline Declarative Programming contd Dataflow Variables contd Expressions and Statements Functions
CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures. Dan Grossman Autumn 2018
CSE341: Programming Languages Lecture 17 Implementing Languages Including Closures Dan Grossman Autumn 2018 Typical workflow concrete syntax (string) "(fn x => x + x) 4" Parsing Possible errors / warnings
CS4215 Programming Language Implementation. Martin Henz
CS4215 Programming Language Implementation Martin Henz Thursday 15 March, 2012 2 Chapter 11 impl: A Simple Imperative Language 11.1 Introduction So far, we considered only languages, in which an identifier
CS422 - Programming Language Design
1 CS422 - Programming Language Design Elements of Functional Programming Grigore Roşu Department of Computer Science University of Illinois at Urbana-Champaign 2 The two languages that we defined so far
Closures. Mooly Sagiv. Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming
Closures Mooly Sagiv Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming t ::= x x. t t t Call-by-value big-step Operational Semantics terms variable v ::= values abstraction x.
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
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
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 ( )
CS558 Programming Languages
CS558 Programming Languages Winter 2017 Lecture 6a Andrew Tolmach Portland State University 1994-2017 Iteration into Recursion Any iteration can be written as a recursion, e.g. while (c) {e Scala is equivalent
Closures. Mooly Sagiv. Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming
Closures Mooly Sagiv Michael Clarkson, Cornell CS 3110 Data Structures and Functional Programming Summary 1. Predictive Parsing 2. Large Step Operational Semantics (Natural) 3. Small Step Operational Semantics
Call with Current Continuation Patterns
Call with Current Continuation Patterns Darrell Ferguson Dwight Deugo August 24, 2001 Abstract This paper outlines the recurring use of continuations. A brief overview of continuations is given. This is
From Syntactic Sugar to the Syntactic Meth Lab:
From Syntactic Sugar to the Syntactic Meth Lab: Using Macros to Cook the Language You Want a V E N E TRUT H Brandeis S PA R T U N T O I T S I N N E R M OS T COMPUTER SCIENCE 21B: Structure and Interpretation
Chapter 1. Fundamentals of Higher Order Programming
Chapter 1 Fundamentals of Higher Order Programming 1 The Elements of Programming Any powerful language features: so does Scheme primitive data procedures combinations abstraction We will see that Scheme
6.001, Spring Semester, 1998, Final Exam Solutions Your Name: 2 Part c: The procedure eval-until: (define (eval-until exp env) (let ((return (eval-seq
1 MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Computer Science 6.001 Structure and Interpretation of Computer Programs Spring Semester, 1998, Final Exam Solutions Your
G Programming Languages Spring 2010 Lecture 4. Robert Grimm, New York University
G22.2110-001 Programming Languages Spring 2010 Lecture 4 Robert Grimm, New York University 1 Review Last week Control Structures Selection Loops 2 Outline Subprograms Calling Sequences Parameter Passing
Programming Languages and Compilers (CS 421)
Programming Languages and Compilers (CS 421) Elsa L Gunter 2112 SC, UIUC http://courses.engr.illinois.edu/cs421 Based in part on slides by Mattox Beckman, as updated by Vikram Adve and Gul Agha 9/11/17
Supplementary Notes on Exceptions
Supplementary Notes on Exceptions 15-312: Foundations of Programming Languages Frank Pfenning Lecture 9 September 25, 2002 In this lecture we first give an implementation of the C-machine for the fragment
Continuation Passing Style. Continuation Passing Style
161 162 Agenda functional programming recap problem: regular expression matcher continuation passing style (CPS) movie regular expression matcher based on CPS correctness proof, verification change of
Semantic Analysis. Outline. The role of semantic analysis in a compiler. Scope. Types. Where we are. The Compiler so far
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 Statically vs. Dynamically typed languages
CS251 Programming Languages Handout # 36 Prof. Lyn Turbak April 4, 2007 Wellesley College Revised April 14, Scoping in Hofl
CS251 Programming Languages Handout # 36 Prof. Lyn Turbak April 4, 2007 Wellesley College Revised April 14, 2007 Scoping in Hofl April 10 Added a new section on the handling of bindrec in the substitution
Verified compilation of a first-order Lisp language
Verified compilation of a first-order Lisp language Lecture 7 MPhil ACS & Part III course, Functional Programming: Implementation, Specification and Verification Magnus Myreen Michaelmas term, 2013 Interpreter
Lecture 16: Object Programming Languages
Lecture 16: Object Programming Languages Introduction Corresponds to EOPL 5.1 and 5.2 Goal: to introduce Object Oriented Programming Language (OOPL) concepts using the EOPL extensible language framework
A brief tour of history
Introducing Racket λ A brief tour of history We wanted a language that allowed symbolic manipulation Scheme The key to understanding LISP is understanding S-Expressions Racket List of either atoms or
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
Lecture 6: The Declarative Kernel Language Machine. September 13th, 2011
Lecture 6: The Declarative Kernel Language Machine September 13th, 2011 Lecture Outline Computations contd Execution of Non-Freezable Statements on the Abstract Machine The skip Statement The Sequential
Agenda. CS301 Session 9. Abstract syntax: top level. Abstract syntax: expressions. The uscheme interpreter. Approaches to solving the homework problem
CS301 Session 9 The uscheme interpreter Agenda Approaches to solving the homework problem 1 2 Abstract syntax: top level datatype toplevel = EXP of exp DEFINE of name * lambda VAL of name * exp USE of
Iterators. Lecture 24: Iterators & Exceptions. Implementing Iterators. When Good Programs Go Bad! - where! Abstract over control structures (in Clu)!
Iterators Lecture 24: Iterators & Exceptions CSC 131 Fall, 2014 Kim Bruce Abstract over control structures (in Clu) - where for c : char in string_chars(s) do string_chars = iter (s : string) yields (char);
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,
Category Item Abstract Concrete
Exceptions To make things simple we ll first consider a simple failure mechanism. CMPSCI 630: Programming Languages Exceptions and Continuations Spring 2009 (with thanks to Robert Harper) Like exceptions,
Discussion 12 The MCE (solutions)
Discussion 12 The MCE (solutions) ;;;;METACIRCULAR EVALUATOR FROM CHAPTER 4 (SECTIONS 4.1.1-4.1.4) of ;;;; STRUCTURE AND INTERPRETATION OF COMPUTER PROGRAMS ;;;from section 4.1.4 -- must precede def of
Lectures Basics in Procedural Programming: Machinery
Lectures 3-4-5-6 Basics in Procedural Programming: Machinery February 21-28, 2014 2014-03-01 11:04:07 1/48 Lecture3-6E-2014.pdf (#21) Basics in Procedural Programming: Machinery Naming and Binding Mutable
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,
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
C311 Lab #3 Representation Independence: Representation Independent Interpreters
C311 Lab #3 Representation Independence: Representation Independent Interpreters Will Byrd webyrd@indiana.edu February 5, 2005 (based on Professor Friedman s lecture on January 29, 2004) 1 Introduction
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
COP4020 Fall 2006 Final Exam
COP4020 Fall 2006 Final Exam Name: (Please print) Put the answers on these sheets. You can collect 100 points in total for this exam. 1. Consider the following Ada program fragment: search: loop i := i+1;
CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures
CSE413: Programming Languages and Implementation Racket structs Implementing languages with interpreters Implementing closures Dan Grossman Fall 2014 Hi! I m not Hal J I love this stuff and have taught
Lecture 12: Conditional Expressions and Local Binding
Lecture 12: Conditional Expressions and Local Binding Introduction Corresponds to EOPL 3.3-3.4 Please review Version-1 interpreter to make sure that you understand how it works Now we will extend the basic
Begin at the beginning
Begin at the beginning Expressions (Syntax) Exec-time Dynamic Values (Semantics) Compile-time Static Types 1. Programmer enters expression 2. ML checks if expression is well-typed Using a precise set of
INF 102 CONCEPTS OF PROG. LANGS FUNCTIONAL COMPOSITION. Instructors: James Jones Copyright Instructors.
INF 102 CONCEPTS OF PROG. LANGS FUNCTIONAL COMPOSITION Instructors: James Jones Copyright Instructors. Topics Recursion Higher-order functions Continuation-Passing Style Monads (take 1) Identity Monad
Chapter 13. Recursion. Copyright 2016 Pearson, Inc. All rights reserved.
Chapter 13 Recursion Copyright 2016 Pearson, Inc. All rights reserved. Learning Objectives Recursive void Functions Tracing recursive calls Infinite recursion, overflows Recursive Functions that Return
LECTURE 18. Control Flow
LECTURE 18 Control Flow CONTROL FLOW Sequencing: the execution of statements and evaluation of expressions is usually in the order in which they appear in a program text. Selection (or alternation): a
n n Try tutorial on front page to get started! n spring13/ n Stack Overflow!
Announcements n Rainbow grades: HW1-6, Quiz1-5, Exam1 n Still grading: HW7, Quiz6, Exam2 Intro to Haskell n HW8 due today n HW9, Haskell, out tonight, due Nov. 16 th n Individual assignment n Start early!
6.821 Programming Languages Handout Fall MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Compvter Science
6.821 Programming Languages Handout Fall 2002 MASSACHVSETTS INSTITVTE OF TECHNOLOGY Department of Electrical Engineering and Compvter Science Problem Set 6 Problem 1: cellof Subtyping Do exercise 11.6
Announcements. Scope, Function Calls and Storage Management. Block Structured Languages. Topics. Examples. Simplified Machine Model.
CS 242 2007 Scope, Function Calls and Storage Management John Mitchell Announcements Homework Returned in class Wed; afterwards in 4 th Floor Gates Cabinet SCPD students: attach routing slip, will be returned
Programming Languages: Application and Interpretation
Programming Languages: Application and Interpretation Version 6.7 October 26, 2016 This is the documentation for the software accompanying the textbook Programming Languages: Application and Interpretation
The Scheme Machine. Robert G. Burger. Indiana University Computer Science Department Lindley Hall 215 Bloomington, Indiana
The Scheme Machine Robert G. Burger Indiana University Computer Science Department Lindley Hall 215 Bloomington, Indiana 47405 burger@cs.indiana.edu Indiana University Computer Science Department Technical
The Compiler So Far. Lexical analysis Detects inputs with illegal tokens. Overview of Semantic Analysis
The Compiler So Far Overview of Semantic Analysis Adapted from Lectures by Profs. Alex Aiken and George Necula (UCB) Lexical analysis Detects inputs with illegal tokens Parsing Detects inputs with ill-formed
Data Abstraction. An Abstraction for Inductive Data Types. Philip W. L. Fong.
Data Abstraction An Abstraction for Inductive Data Types Philip W. L. Fong pwlfong@cs.uregina.ca Department of Computer Science University of Regina Regina, Saskatchewan, Canada Introduction This lecture
Anatomy of a Compiler. Overview of Semantic Analysis. The Compiler So Far. Why a Separate Semantic Analysis?
Anatomy of a Compiler Program (character stream) Lexical Analyzer (Scanner) Syntax Analyzer (Parser) Semantic Analysis Parse Tree Intermediate Code Generator Intermediate Code Optimizer Code Generator
CS558 Programming Languages. Winter 2013 Lecture 4
CS558 Programming Languages Winter 2013 Lecture 4 1 PROCEDURES AND FUNCTIONS Procedures have a long history as an essential tool in programming: Low-level view: subroutines give a way to avoid duplicating
Control in Sequential Languages
Control in Sequential Languages Structured Programming Go to considered harmful Exceptions structured jumps that may return a value dynamic scoping of exception handler Continuations Function representing
Lecture 8: Recursion and Iteration. Exceptions. Declarative Programming.
Lecture 8: Recursion and Iteration. Exceptions. Declarative Programming. September 26th, 2010 Lecture 8: Recursion and Iteration. Exceptions. Declarative Programming. (1/48) Lecture Outline Memory Management,
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
CSc 520 Principles of Programming Languages. 26 : Control Structures Introduction
CSc 520 Principles of Programming Languages 26 : Control Structures Introduction Christian Collberg Department of Computer Science University of Arizona collberg+520@gmail.com Copyright c 2008 Christian
CSE 413 Midterm, May 6, 2011 Sample Solution Page 1 of 8
Question 1. (12 points) For each of the following, what value is printed? (Assume that each group of statements is executed independently in a newly reset Scheme environment.) (a) (define x 1) (define
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,