Ti1220 Lecture 2: Names, Bindings, and Scopes
Upcoming SlideShare
Loading in...5
×
 

Ti1220 Lecture 2: Names, Bindings, and Scopes

on

  • 2,150 views

 

Statistics

Views

Total Views
2,150
Views on SlideShare
1,266
Embed Views
884

Actions

Likes
0
Downloads
22
Comments
0

1 Embed 884

http://department.st.ewi.tudelft.nl 884

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Ti1220 Lecture 2: Names, Bindings, and Scopes Ti1220 Lecture 2: Names, Bindings, and Scopes Presentation Transcript

  • Lecture 2: Names, Bindings, and Scopes(Sebesta Chapter 5) TI1220 2012-2013 Concepts of Programming Languages Eelco Visser / TU Delft
  • Outline Messages from the lab Names Variables Binding & binding time Scope Demo: Spoofax name binding language
  • Messages from the Lab
  • “There were not a lot of students at the lab. This ofcourse is ok for the first week, but students shouldbe told that they stand no chance of passingthe graded assignments without the tutorials, or theexam without the graded assignments.”
  • “There are too manyrooms for the numberof students. Could youmention that theyshould start filling therooms from the top, oneby one and then movedown as they fill up.Room 0.010 is quiteunhandy for labs becauseof the cubicles.”
  • “WebLab of course does not workproperly in Internet Explorer, weshould tell students that.”
  • Email addresses e.visser@tudelft.nl: for personal questions about grades and such ti1220.ewi@gmail.com: for general questions about the lab ti1220.ewi+lab@gmail.com: for questions about the lab (addresses all student assistants)Policies Our first response: did you ask this question at the lab? We’re closed in the weekend (in principle) Please report problems with WebLab immediately
  • Names (Identifiers)
  • Name Forms [a-zA-Z][a-zA-Z0-9_]* -> ID %% typical"$" [a-zA-Z][a-zA-Z0-9_]* -> PhpID[$@%][a-zA-Z][a-zA-Z0-9_]* -> PerlID"@" [a-zA-Z][a-zA-Z0-9_]* -> RubyInstanceVar"@@" [a-zA-Z][a-zA-Z0-9_]* -> RubyClassVar
  • Case Sensitive or Case Insensitive? foobar == FooBar == FOOBAR ? C-based languages: case sensitive C convention: variable names only lower case letters Pascal: case insensitive Java convention: CamelCase instead of under_scores
  • Special Words keyword: identifier with special type meaning in certain contexts Integer Apple Integer = 4 name Integer Realpackage example; Real Integerclass User { private String name; public String get_name { Fortran return name; }} Java reserved word: special word that cannot be used as a name
  • Variables
  • A program variable is an abstraction of acomputer memory cell or collection of cellsmachine language: absolute numeric address of data assembly language: names for data
  • The attributes of a variable: Name Address Value Type Lifetime Scope
  • the address of a variable is the machinememory address with which it is associated def gcd(x: Long, y: Long): Long = if (y == 0) x else gcd(y, x % y) each call to gcd creates new instances of x and y alias: multiple variables accessing same memory location (more next week)
  • Type & Value the type of a variable determines the range of values the variable can store and the set ofoperations that are defined for values of the type the value of a variable is the contents of thememory cell or cells associated with the variable
  • Binding & Binding Time
  • a binding is an association between an attribute and an entityExample bindings variable to type variable to value function call to function definition
  • Binding Variable Identifiers bindingdefining occurrence val msg = "Hello, " + "world!" println(msg) applied occurrence val variables cannot be rebound
  • Binding Variable Identifiers bindingdefining occurrence var greeting = "Hello, world!" greeting = "Leave me alone, world!"rebinding var variables can be rebound
  • Binding Function Identifiers bindingdefining occurrence def widthOfLength(s: String) = s.length.toString.length val maxWidth = widthOfLength(longestLine) applied occurrence
  • Binding Class Identifiers bindingdefining occurrence class ChecksumAccumulator { var sum = 0 } var acc = new ChecksumAccumulator var csa = new ChecksumAccumulator acc.sum = 3 csa = acc applied occurrence
  • Rebinding vs Mutationclass ChecksumAccumulator { var sum = 0} bindingvar acc = new ChecksumAccumulatorvar csa = new ChecksumAccumulator mutationacc.sum = 3csa = acc rebinding
  • Namespaces object foo { val foo : Int = 0 def foo(x : Int) = x + 1 } object bar { def bar() = foo.foo(foo.foo) }variables, functions, objects are in separate name spaces
  • the time at which a binding takes places is called binding timeExample binding times language design time language implementation time compile time load time link time run time
  • Type int in C bound to range of possible values (e.g. 32 bit words) at language implementation timeVariable in Java bound to data type at compile time Variable in JavaScript bound to data type at run time
  • Symbolic Constants (C) 0 -17.8 20 -6.7 40 4.4 60 15.6#include <stdio.h> 80 26.7#define LOWER 0 /* lower limit of table */ 100 37.8 120 48.9#define UPPER 300 /* upper limit */ 140 60.0#define STEP 20 /* step size */ 160 71.1 180 82.2 200 93.3/* print Fahrenheit-Celsius table */ 220 104.4 240 115.6main() { 260 126.7 int fahr; 280 137.8 300 148.9 for (fahr = LOWER; fahr <= UPPER; fahr = fahr + STEP) printf("%3d %6.1fn", fahr, (5.0 / 9.0) * (fahr - 32));}compile-time binding of values
  • Typedefs (C)typedef int Length;Length len, maxlen; compile-time binding of type nameLength *lengths[];typedef struct tnode *Treeptr;typedef struct tnode { /* the tree node: */ char *word; /* points to the text */ int count; /* number of occurrences */ struct tnode *left; /* left child */ struct tnode *right; /* right child */} Treenode;Treeptr talloc(void) { return (Treeptr) malloc(sizeof(Treenode));}
  • Function Definitions and Calls (Scala) def max(x: Int, y: Int): Int = { if (x > y) x else y } max(3, 5) function statically bound, argument values dynamically bound to formal parameters
  • Recursion (Scala)def gcd(x: Long, y: Long): Long = if (y == 0) x else gcd(y, x % y) def fib(x: Long): Long = if (x <= 0) 1 else if (x == 1) 1 else fib(x - 1) + fib(x - 2) recursion requires dynamic binding of variables
  • a binding is static when it occurs before run time and remains unchanged throughout execution a binding is dynamic if it first occurs during run time or can change in the course of program execution
  • Function Expressions (JS)// This function expression defines a function that squares its argument.// Note that we assign it to a variablevar square = function(x) { return x * x;}var q = square(10);function square(x) { return x * x; }// Function expressions can include names, which is useful for recursion.var f = function fact(x) { if (x <= 1) return 1; else return x * fact(x - 1);};// Function expressions can also be used as arguments to other functions:data.sort(function(a, b) { return a - b; });// Function expressions are sometimes defined and immediately invoked:var tensquared = (function(x) { return x * x; }(10));
  • var square = function foo(x) {! return x * x;};var z = square;var r = z(10);console.log(r);function squareF(x) { return x * x; }var q = squareF(10);console.log(q);var sq = squareF;console.log("sq: " + sq);console.log("sq(12): " + sq(12));console.log(foo(3));
  • Type binding of variable How specified? explicit vs implicit When bound? static vs dynamic
  • an explicit declaration is astatement in a program that listsvariable names and specifies that they are a particular type an implicit declaration is a means of associating variables with types through default conventions, rather than declaration statements
  • Fortran: static types, implicitly declaredIn implicit typing, all constants, variablesand arrays beginning with the letters I, J,K, L, M, or N are automatically taken tobe of type INTEGER.Constants, variables and arrays beginningwith all other letters are assumed to beREAL.Thus, with implicit typing, the variableCOUNT is REAL whilst the variableKOUNT is an INTEGER.Implicit typing can be overridden withexplicit type declaration. source: http://www.obliquity.com/computer/fortran/datatype.html
  • Perl: implicitly declared with different name spaces$a : scalar (string or numeric value)#a : array%a : hash structure
  • Variables and Expressions (C)#include <stdio.h> static types, explicitly declared/* print Fahrenheit-Celsius table for fahr = 0, 20, ..., 300 */int main() { int fahr, celsius; int lower, upper, step; lower = 0; /* lower limit of temperature scale */ upper = 300; /* upper limit */ step = 20; /* step size */ fahr = lower; while (fahr <= upper) { celsius = 5 * (fahr - 32) / 9; printf("%dt%dn", fahr, celsius); fahr = fahr + step; } return 0;}
  • type inference: implicit type declaration using context Languages with type inference ML Haskell OCaml F# Scala Visual BASIC 9.0+ Go
  • Scala: static types, inferred from contextdef widthOfLength(s: String) = s.length.toString.lengthval lines = Source.fromFile(args(0)).getLines.toListval longestLine = lines.reduceLeft( (a, b) => if (a.length > b.length) a else b)val maxWidth = widthOfLength(longestLine)
  • dynamic type binding: variable is bound to type when it is assigned a valueLanguages with dynamic type binding Ruby JavaScript Lisp Scheme Python PHP
  • Variable Declaration (JS)var i;var sum;var i, sum;var message = "hello";var i = 0, j = 0, k = 0;for(var i = 0; i < 10; i++) console.log(i);for(var i = 0, j=10; i < 10; i++,j--)console.log(i*j);for(var p in o) console.log(p);var i = 10;i = "ten";
  • JavaScript: dynamic type bindinglist = [10.2, 3.5];list = 47; Ruby all variables are references all data are objects (there is only one type) any variable can reference an object
  • Disadvantages of dynamic typing programs are less reliable: types not checked by compiler cost of checking types at run time
  • next week: storage bindings and lifetime
  • Scope
  • the scope of a variable is the range ofstatements in which the variable is visible a variable is local in a program unit or block if it is declared therethe non-local variables are those thatare visible but not declared in a program unit
  • class ChecksumAccumulator { private var sum = 0 def add(b: Byte): Unit = { sum += b } def checksum(): Int = { return ~(sum & 0xFF) + 1 }} Scala: variable sum is non-local for methods add and checksum
  • static scoping: scope of variable canbe statically determined nested scopes: Ada, JavaScript, Scheme, Scala, F#, Python non-nested scopes: C-based languages
  • function big() { function sub1() { var x = 7; sub2(); } function sub2() { var y = x; } var x = 3; sub1();} static scoping in JavaScript
  • Variable Scope (JS)var scope = "global";// Declare a global variablefunction checkscope() { var scope = "local"; // Declare a local variable with the same name return scope; // Return the local value, not the global one}checkscope()// => "local"
  • Variable Scope (JS)scope = "global"; // Declare a global variable, even without var.function checkscope2() { scope = "local"; // Oops! We just changed the global variable. myscope = "local"; // This implicitly declares a new global variable. return [ scope, myscope ]; // Return two values.}checkscope2() // => ["local", "local"]: has side effects!scope // => "local": global variable has changed.myscope // => "local": global namespace cluttered up.
  • Nested Functions (JS) function hypotenuse(a, b) { function square(x) { return x * x; } return Math.sqrt(square(a) + square(b)); }var scope = "global scope"; // A global variablefunction checkscope() { var scope = "local scope"; // A local variable function nested() { var scope = "nested scope"; // A nested scope of local variables return scope; // Return the value in scope here } return nested();}checkscope() // => "nested scope"
  • block: sections in which allocation of storage for variables is allocatedif (list[i] < list[j]) { int temp; void sub() { temp = list[i]; int count; list[i] = list[j]; ... list[j] = temp; while (...) {} int count; count++; ... } ... Java and C# do not allow } shadowing of variables
  • def printMultiTable() { var i = 1 // only i in scope here block scope in Scala: while (i <= 10) { var j = 1 order of declaration // both i and j in scope here while (j <= 10) { matters val prod = (i * j).toString // i, j, and prod in scope here var k = prod.length // i, j, prod, and k in scope here while (k < 4) { print(" ") k += 1 } print(prod) j += 1 } // i and j still in scope; prod and k out of scope println() i += 1 } // i still in scope; j, prod, and k out of scope}
  • Function Scope and Hoisting (JS)function test(o) { var i = 0; // i is defined throughout function if (typeof o == "object") { var j = 0; // j is defined everywhere, not just block for ( var k = 0; k < 10; k++) { // k is defined everywhere, not just loop console.log(k); // print numbers 0 through 9 } console.log(k); // k is still defined: prints 10 } console.log(j); // j is defined, but may not be initialized} JavaScript does not have block scope!
  • Use Before Declarationvar scope = "global";function f() { console.log(scope); // Prints "undefined", not "global" var scope = "local"; // Variable initialized here, but defined everywhere console.log(scope); // Prints "local"}function f() { var scope; // Local variable is declared at the top of the function console.log(scope); // It exists here, but still has "undefined" value scope = "local"; // Now we initialize it and give it a value console.log(scope); // And here it has the value we expect}
  • let val name1 = expression1 ... val namen = expressionnin expressionend; let val top = a + b val bottom = c - d in top / bottom end;let binding in ML
  • Describing Static Name Binding Rules
  • module namesimports NaBL: Spoofax Name Binding Language include/Delft namespaces module blog Module Entity imports user Property entity BlogPosting {rules name : String poster : User Module(x, _) : body : String defines Module x scopes Entity blog : Blog title : String Entity(x, _) : } defines Entity x of type Type(x) scopes Property entity Blog { title : String Property(x, t) : author : Blog defines Property x of type t } Type(x) : refers to Entity x entity User { refers to Entity "String" name : String refers to Entity "Int" }
  • Reading & Programming in Week 2Reading: Sebesta Chapter 5: Names, Bindings, ScopesWebLab: C tutorial JavaScript tutorial More Scala tutorial Grammars and regular expressions Week 3: Dynamic Binding & Storage