1
play

1 Algol 60 Pass-by-name Algol 68 Substitute text of actual - PDF document

May 25, 2023 •273 likes •358 views

CS 242 Language Sequence The Algol Family and ML Lisp Algol 60 Algol 68 John Mitchell Pascal ML Modula Many other languages: Algol 58, Algol W, Euclid, EL1, Mesa (PARC), Reading: Chapter 5 Modula-2, Oberon, Modula-3 (DEC) Algol 60

  1. CS 242 Language Sequence The Algol Family and ML Lisp Algol 60 Algol 68 John Mitchell Pascal ML Modula Many other languages: Algol 58, Algol W, Euclid, EL1, Mesa (PARC), … Reading: Chapter 5 Modula-2, Oberon, Modula-3 (DEC) Algol 60 Algol 60 Sample � Basic Language of 1960 real procedure average(A,n); • Simple imperative language + functions real array A; integer n; no array bounds • Successful syntax, BNF -- used by many successors begin – statement oriented real sum; sum := 0; – Begin … End blocks (like C { … } ) for i = 1 step 1 until n do – if … then … else • Recursive functions and stack storage allocation sum := sum + A[i]; • Fewer ad hoc restrictions than Fortran average := sum/n no ; here – General array references: A[ x + B[3]*y] end; • Type discipline was improved by later languages • Very influential but not widely used in US set procedure return value by assignment Algol Joke Some trouble spots in Algol 60 � Question � Type discipline improved by later languages • Is x := x equivalent to doing nothing? • parameter types can be array – no array bounds � Interesting answer in Algol • parameter type can be procedure integer procedure p; – no argument or return types for procedure parameter begin � Parameter passing methods …. • Pass-by-name had various anomalies p := p – “Copy rule” based on substitution, interacts with side effects …. • Pass-by-value expensive for arrays end; � Some awkward control issues • Assignment here is actually a recursive call • goto out of block requires memory management 1

  2. Algol 60 Pass-by-name Algol 68 � Substitute text of actual parameter � Considered difficult to understand • Unpredictable with side effects! • Idiosyncratic terminology � Example – types were called “modes” – arrays were called “multiple values” procedure inc2(i, j); • vW grammars instead of BNF integer i, j; – context-sensitive grammar invented by A. van Wijngaarden begin begin • Elaborate type system i := i+1; k := k+1; • Complicated type conversions j := j+1 A[k] := A[k] +1 � Fixed some problems of Algol 60 end; end; • Eliminated pass-by-name inc2 (k, A[k]); � Not widely adopted Is this what you expected? Algol 68 Modes Other features of Algol 68 � Primitive modes � Compound modes � Storage management • int • arrays • Local storage on stack • real • structures • Heap storage, explicit alloc and garbage collection • char • procedures � Parameter passing • bool • sets • Pass-by-value • string • pointers • Use pointer types to obtain Pass-by-reference • compl (complex) � Assignable procedure variables • bits Rich and structured • Follow “orthogonality” principle rigorously • bytes type system is a • sema (semaphore) major contribution of • format (I/O) Algol 68 Source: Tanenbaum, Computing Surveys • file Pascal Limitations of Pascal � Revised type system of Algol � Array bounds part of type illegal • Good data-structuring concepts procedure p(a : array [1..10] of integer) – records, variants, subranges procedure p(n: integer, a : array [1..n] of integer) • More restrictive than Algol 60/68 • Attempt at orthogonal design backfires – Procedure parameters cannot have procedure parameters – parameter must be given a type � Popular teaching language – type cannot contain variables � Simple one-pass compiler How could this have happened? Emphasis on teaching � Not successful for “industrial-strength” projects • Kernighan -- Why Pascal is not my favorite language • Left niche for C; niche has expanded!! 2

  3. C Programming Language ML � Typed programming language Designed for writing Unix by Dennis Ritchie � Intended for interactive use � Evolved from B, which was based on BCPL � Combination of Lisp and Algol-like features • B was an untyped language; C adds some checking • Expression-oriented � Relation between arrays and pointers • Higher-order functions • An array is treated as a pointer to first element • Garbage collection • E1[E2] is equivalent to ptr dereference *((E1)+(E2)) • Abstract data types • Pointer arithmetic is not common in other languages • Module system � Ritchie quote • Exceptions • “C is quirky, flawed, and a tremendous success.” � General purpose non-C-like, not OO language • Related languages: Haskell, OCAML, … Why study ML ? History of ML � Learn an important language that’s different � Robin Milner � Discuss general programming languages issues � Logic for Computable • Types and type checking Functions – General issues in static/dynamic typing • Stanford 1970-71 – Type inference • Edinburgh 1972-1995 – Polymorphism and Generic Programming • Memory management � Meta-Language of the – Static scope and block structure LCF system – Function activation records, higher-order functions • Theorem proving • Control • Type system – Force and delay – Exceptions • Higher-order functions – Tail recursion and continuations Logic for Computable Functions LCF proof search � Dana Scott, 1969 � Tactic: function that tries to find proof • Formulate logic for proving properties of typed functional programs succeed and return proof � Milner tactic(formula) = search forever • Project to automate logic fail • Notation for programs • Notation for assertions and proofs • Need to write programs that find proofs � Express tactics in the Meta-Language (ML) – Too much work to construct full formal proof by hand � Use type system to facilitate correctness • Make sure proofs are correct 3

  4. Tactics in ML type system Function types in ML f : A → B means � Tactic has a functional type for every x ∈ A, tactic : formula → proof � Type system must allow “failure” some element y=f(x) ∈ B f(x) = run forever terminate by raising an exception succeed and return proof tactic(formula) = search forever fail and raise exception In words, “if f(x) terminates normally, then f(x) ∈ B.” Addition never occurs in f(x)+3 if f(x) raises exception. This form of function type arises directly from motivating application for ML. Integration of type system and exception mechanism mentioned in Milner’s 1991 Turing Award. Higher-Order Functions Basic Overview of ML � Tactic is a function � Interactive compiler: read-eval-print � Method for combining tactics is a function on • Compiler infers type before compiling or executing functions Type system does not allow casts or other loopholes. � Examples � Example: - (5+3)-2; f(tactic 1 , tactic 2 ) = > val it = 6 : int λ formula. try tactic 1 (formula) - if 5>3 then “Bob” else “Fido”; else tactic 2 (formula) > val it = “Bob” : string - 5=4; > val it = false : bool Overview by Type Compound Types � Booleans � Tuples • true, false : bool • (4, 5, “noxious”) : int * int * string • if … then … else … (types must match) � Lists � Integers • nil • 0, 1, 2, … : int • 1 :: [2, 3, 4] infix cons notation • +, * , … : int * int → int � Records and so on … � Strings • {name = “Fido”, hungry=true} • “Austin Powers” : {name : string, hungry : bool} � Reals • 1.0, 2.2, 3.14159, … decimal point used to disambiguate 4

  5. Patterns and Declarations Functions and Pattern Matching � Patterns can be used in place of variables � Anonymous function <pat> ::= <var> | <tuple> | <cons> | <record> … • fn x => x+1; like Lisp lambda � Value declarations � Declaration form • General form • fun <name> <pat 1 > = <exp 1 > val <pat> = <exp> | <name> <pat 2 > = <exp 2 > … • Examples | <name> <pat n > = <exp n > … val myTuple = (“Conrad”, “Lorenz”); val (x,y) = myTuple; � Examples val myList = [1, 2, 3, 4]; • fun f (x,y) = x+y; actual par must match pattern (x,y) val x::rest = myList; • fun length nil = 0 • Local declarations | length (x::s) = 1 + length(s); let val x = 2+3 in x*4 end; Map function on lists More functions on lists � Apply function to every element of list � Reverse a list fun map (f, nil) = nil fun reverse nil = nil | map (f, x::xs) = f(x) :: map (f,xs); | reverse (x::xs) = append ((reverse xs), [x]); � Append lists map (fn x => x+1, [1,2,3]); [2,3,4] fun append(nil, ys) = ys � Compare to Lisp | append(x::xs, ys) = x :: append(xs, ys); � Questions (define map • How efficient is reverse? (lambda (f xs) • Can you do this with only one pass through list? (if (eq? xs ()) () (cons (f (car xs)) (map f (cdr xs))) ))) More efficient reverse function Datatype Declarations fun reverse xs = � General form let fun rev (nil, z) = (nil, z) datatype <name> = <clause> | … | <clause> | rev(y::ys, z) = rev(ys, y::z) <clause> ::= <constructor> |<contructor> of <type> val (u,v) = rev(xs,nil) � Examples in v • datatype color = red | yellow | blue end; – elements are red, yellow, blue • datatype atom = atm of string | nmbr of int – elements are atm(“A”), atm(“B”), …, nmbr(0), nmbr(1), ... 1 3 • datatype list = nil | cons of atom*list 2 2 2 2 – elements are nil, cons(atm(“A”), nil), … 3 3 1 3 1 1 cons(nmbr(2), cons(atm(“ugh”), nil)), ... 5

Recommend

More recommend