CA341 - Comparative Programming Languages

Transcription

1 CA341 - Comparative Programming Languages and David Sinclair Data, Values and Types In 1976 Niklaus Wirth (inventor of Pascal, Modula, Oberon, etc) wrote a book called Algorithms + Data Structures = Programs which is one of the most influential books on programming and computer science. Data, how we store it and manipulate it, is at the heart of any computer program. A value is any entity that can be manipulated by a program. It can be evaluated, stored, passed as a parameter to a function or procedure and returned from a function. Different languages support different kinds of values.

2 Types and Operations Most programming languages group values in to types. A type is a set of values. Hence, if we say that v is a value of type T, we are simply saying v T. If an expression E is of type T, the we are saying that the result of evaluating E is a value of type T. We place one restriction of the kind of sets that can be used to form types. Each operation associated with a type must act uniformly when applied to all values of the type. {..., 2, 1,0,1,2,...} is a type since addition, subtraction, multiplication, etc., can be applied uniformly over all the values. {false, true} is a type since conjunction, disjunction and negation can be applied uniformly over all the values. {false,13,sunday} is not a type since there are no operations that can be applied uniformly to the values of this set. Types are sets that defined by the values the set contains and the operations on these values. Primitive Types A primitive value is one that cannot be decomposed into simpler values. A primitive type is a set of primitive values with a set of uniform operations. Every programming language has built-in primitive types, and some languages allow the user to define new primitive types. Depending on the targeted application domain, different languages support different built-in primitive types. Languages aimed at the commercial data processing domain (such as Cobol) have built-in primitive types that support fixed length string and fixed-point numbers. Languages aimed at scientific computations (such as FORTRAN) tend to have built-in types that support real numbers (possibly of arbitrary precision) and complex numbers. Languages aimed at string processing (such as Snobol) have built-in types that support arbitrary length strings.

3 Primitive Types (2) The most common built-in types are Boolean, Character, Integer and Floating, though they have different type names among the different programming languages. The Boolean type has 2 values, either denoted by the literals true and false, or by predefined values (e.g. in C, 0 is false and any non-zero numeric value is true). The Character type is a language defined or implementation defined set of characters, typically ASCII (128 characters), ISO Latin (256 characters) or UNICODE (65,536 characters). The Integer type is a language defined or implementation defined range of whole numbers, typically defined by the target computer s word size and integer arithmetic capabilities. On a 32-bit machine with 2s complement arithmetic, the range is { 2,147,483,648,...,0,...,+2,147,483,647}. Primitive Types (3) The Floating type is a language defined or implementation defined subset of real numbers. The range and precision is determined by the target computer s word size and floating-point arithmetic capabilities. The Character, Integer and Floating types are usually implementation-defined, however some languages, such as Java, precisely defines all its types. The cardinality of a type T, denoted #T, is the number of distinct values in the type. For example, #Boolean = 2. Not all languages have distinct Boolean and Character types. In C++, the Boolean type bool is actually just small numbers. Similarly, in C, C++ and Java the Character type char are just small integers. There is no difference between character A and the value 65.

4 Primitive Types (4) Many languages have different sizes of integers. They even have the same names, such as short, int and long in Java, C and C++. But be very careful! Consider the following Java snippet. int countrypop ; long worldpop; While this is fine for Java, since no country at the moment has a population more that 2 billion, the same declarations in C/C++ would generally cause a problem as the int type in C/C++ only ranges up to 32,767 on a 16-bit machine. On a 32-bit machine an int might range up to 2,147,483,647, but it is implementation specific and not covered by the language standard. Primitive Types (5) Some languages allow the programmer to define the ranges of integer and floating-point types to avoid the type of portability issues we have just seen. type Popoulation is range 0.. 1e10 ; countrypop : Population ; worldpop: Population ; Aside: What is #Population? Ada also allows a programmer to define a new primitive type by completely enumerating the identifiers denotes its values. This is called an enumeration type and its values are called enumerands. type Month is (jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec );

5 Primitive Types (6) A discrete primitive type has a one-to-one mapping with the range of integers. In Ada, the types Boolean, Character and enumerated types are discrete primitive types. This can be very useful. freq : array( Character ) of Natural ; for ch in Character loop freq (ch) := 0; end loop ; type Month is (jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec ); length : array(month) of Natural := (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31); for mth in Month loop put( length (mth)); end loop ; Composite Types A composite value is a value composed from simpler values. It is a fancy name for a data structure. A composite type is a type whose values are composite values. The variety of composite types among different programming languages is vast, but we can group them into the following categories. Cartesian products such as tuples and records. Mappings such as arrays. Disjoint unions such as algebraic types, discriminated records and objects. Recursive types such as lists and trees.

6 Cartesian Products In a Cartesian product, the values from several types are grouped into a tuples. The notation (x,y) denotes a pair whose first value is x and second value is y. We can use the same notation to represent a triple, (x,(y,z)), an extend it further to represent any size tuple. The notation S T represents the set of all pairs. S T = {(x,y) x S,y T} The basic operations on pairs are: construction of a pair from its values selection of either the first (fst) or second (snd) component of the pair. The cardinality of a Cartesian product S T is #(S T) = #S #T Cartesian Products (2) C++ structures can be understood in terms of Cartesian products. enum Month {jan, feb,mar, apr, may, jun, jul, aug, sep, oct, nov, dec}; struct Date { Month m; byte d; }; This structure type has the values: Date = Month byte = {jan,feb,...,nov,dec} {0,1,...,255} The following code snippets show the construction and selection operations. struct Date today = {sep, 12}; printf ( %d%d, today.m+1, today.d); today.m = mar; today.d = 17;

7 Cartesian Products (3) Ada s records are another example of Cartesian products. type Month is (jan, feb, mar, apr, may, jun, jul, aug, sep, oct, nov, dec ); type DayNumber is range ; type Date is record m: Month; d: DayNumber; end record ; The following code snippets show the construction and selection operations. today : Date := (m => sep, d => 12); put(today.d); put( / ); put(today.d); today.m := mar; today.d := 17; Cartesian Products (4) A special case of Cartesian products is when all the tuple components are from the same set. In these cases the tuples are said to be homogeneous. For pairs and more generally: The cardinality is: S 2 = S S S n = S S... S #(S n ) = #S #S... #S = (#S) n The special case of n = 0, says the cardinality of S 0 is 1, the empty tuple Unit. Unit corresponds to the type void in C, C++ and Java; and to type null record in Ada.

8 Mappings The concept of a mapping from one set to another set is very important in programming languages and underlies to important features in programming languages, arrays and functions. The notation m : S T represents a mapping m from set S to set T, i.e. every value in S is mapped to a value in T. If m maps the value x in S to the value y in T, we write y = m(x), and say that y is the image of x under m. The notation S T represents the set of all mapping from S to T. S T = {m x S m(x) T} The cardinality of a mapping is Mappings (2) #(S T) = (#T) #S since each element of S has #T possible values and there are #S of these values in S. An array is an indexed sequence of elements with one element of T for each index (from S). Also the index is finite, so therefore, an array is of type S T and is a finite mapping. Usually the elements of S are consecutive and have a lower bound and an upper bound. The basic operation on arrays are: construction of an array from its elements indexing which selects an given element from an array based on its index.

9 Mappings (3) In C++, an array s index must be integer whose lower bound is 0. The C++ declaration bool flags [3]; is a mapping {0,1,2} {true,false}. The following code snippets show the construction and indexing operations. bool flags = {true, false, true }; flags [ i ] = flags [ i ] & flags [ i 1]; Arrays in Java looks similar in that they have integer indexes whose lower bound is 0, but in fact they are actually objects. Arrays in Python are actually lists that can contain mixed datatypes and hence are not mappings. Multi-dimensional arrays in Python are lists of lists, and hence can be jagged, i.e. each row can be of different sizes. Mappings (4) Arrays in Ada are more flexible than C, C++ and Java in that the index range can be chosen by the programmer and the only restriction on the type of the index is that it is a discrete primitive type. For example, type Colour is (red, green, blue ); type Pixel is array (Colour ) of Boolean ; Hence, Pixel : Colour Boolean Pixel : {red,green,blue} {true,false} and the operations of construction and indexing are implemented as: p1: Pixel := (red => false, green => true, blue => true ); p2: Pixel := (true, false, false ); p1( i ) := not p2( i );

10 Mappings (5) Many programming languages support multi-dimensional arrays. We can think of multi-dimensional arrays as having a single index that is a tuple. Hence, a multi-dimensional array is a mapping from a tuple to a set of values. The following Ada 2-dimensional array type XRange is range ; type YRange is range ; type Window is array (XRange, YRange) of Pixel ; is the mapping Window : {{1,...,512} {1,...,256}} {true,false} Window : {(1,1),(1,2),...,(512,255),(512,256)} {true,false} Mappings (6) Function procedures, supported by some programming languages, are also mappings. For example, in C++ bool is even ( int i ) { return ( i % 2 == 0); } is a mapping Integer Boolean. Even if we change the implementation of is even, it still is the same mapping. Functions with multiple parameters are mappings from a tuple to a set of possible return values. The C++ function float power ( float x, int i ) {... } is a mapping Floating Integer Floating, e.g. (3.0,2) 9.0 and (1.5,3)

11 Disjoint Unions In a disjoint union a value is selected from one of several, possibly different, sets. Let the notation S + T represent the disjoint union of sets S and T. Each element of S +T consists of a tag which identifies which original set the element came from and a variant which is the value from the original set. left S +right T = {left x x S} {right y y T} Where the tags are irrelevant we can leave them out. S +T = {left x x S} {right y y T} The cardinality of a disjoint union is #(S +T) = #S +#T Disjoint Unions (2) The basic operations on disjoint unions are: construction by appropriately tagging each element from both sets. tag test to determine if a variant was from S or T. projection to recover the variant is S or the variant in T. Disjoint unions can be used to understand Haskell s algebraic types, Ada s discriminated records, the set of objects in a Java program and C s unions when declared inside structures.

12 Disjoint Unions (3) Algebraic types in Haskell are declared as follows: data Number = Exact Integer Inexact Float The following code snippet illustrated construction. let pi = Inexact in... The following code snippet illustrated tag test and projection. rounded num = case num of Exact i => i Inexact i => round i round pi will result in the value 3. Disjoint Unions (4) Discriminated records in Ada can be modelled as disjoint unions. type Form is (point, circle, rectangle ); type Figure ( f : Form) is record x, y: Float case f is when point => null ; when circle => r : Float ; when rectangle => w, h: Float end case ; end record ; Figure = point(floating Floating) + circle(floating Floating Floating) +rectangle(floating Floating Floating Floating) Examples are point(2.0, 3.0), circle(0.0, 1.0, 0.5) and rectangle(0.0, 0.0, 3.0, 2.0).

13 Disjoint Unions (5) Consider the following class declarations. class Point { float x, y; }... // methods class Circle extends Point { float radius ; }... // methods class Rectangle extends Point { float width, height ; }... // methods Disjoint Unions (6) The set of objects in this Java program is: Point(Floating Floating) +Circle(Floating Floating Floating) +Rectangle(Floating Floating Floating Floating) +... The +... represents that additional classes can be declared later in the Java program. C unions in themselves are not disjoint unions as there is no tags. Typically C programmers declared unions inside structures, and this can be modelled by disjoint unions. enum Accuracy {exact, inexact }; struct Number { Accuracy acc ; union { int i ; / used when acc = exact / float f ; / used when acc = inexact / } content ; };

14 Recursive Types A recursive type is a type that is defined in terms of itself. The typical recursive types that occur in programming languages are lists and strings. Lists A list a sequence of values. If all the elements of a list are the same type the list is homogeneous, otherwise it is hetrogeneous. The number of elements in a list is called its length. A list with no elements is an empty list. The typical operation on a list are: construction, add a new element as the head of the new list length empty test head selection, select the list s first element tail selection, select all the list other than the first element concatenation, joining two lists Lists In some programming languages lists are called sequences. The equation for finite lists of type T is: T = Unit +(T T ) For integer lists the set of values is: {nil} {cons(i,nil) i Integer} {cons(i,cons(j,nil)) i,j Integer} {cons(i,cons(j,cons(k,nil))) i,j,k Integer} +... In imperative programming languages, like C, C++ and Ada, recursive type are implemented using pointers, but in functional and some object-oriented programming languages, they can be define and implemented directly.

15 An example of Java lists is: class IntList { public IntNode first ; Lists (2) } public IntList (IntNode firtst ) { this. first = first ; } class IntNode { public int elem ; public IntNode succ ; } public IntNode ( int elem, IntNode succ) { this. elem = elem ; this. succ = succ ; } IntList primes = new IntList ( new IntNode (2, new IntNode (3, new IntNode (5, null )))); Lists (3) Haskell has a built-in list type, e.g. [] [1] [1,2,3] but if it didn t, we could define integer lists as data IntList = Nil Cons Int IntList and the above lists can be written as Nil Cons 1 Nil Cons 1 (Cons 2 (Cons 3 Nil ))

16 Strings A string is a sequence of characters. The number of characters in a string is the length of the string. A string with no characters is called the empty string. The typical string operations are: length equality test lexicographical comparison in order to order two strings character selection substring selection concatenation, joining two strings Strings (2) There is no common way to represent strings among the different programming languages. Some languages treat strings as a built-in type and therefore must provide basic string operations. ML adopts this approach. Some programming languages treat strings as an array of characters. The standard array operations, such as index selection, can be applied to strings. Usually common string operations are also provided, e.g. lexicographical comparison. A consequence of this approach is that, once constructed, the string is of fixed-length. Ada adopts this approach. A slightly more versatile approach is to represent a string as a pointer to a character array. This is the approach that C and C++ adopt.

17 Strings (3) In languages that have built-in support for lists, a common approach is to represent a string as a list of characters. Using this approach means that the standard list operations can be applied to strings. This approach is adopted by Python, Haskell and Prolog. Object-oriented languages, such as Java, treat string as objects. These string object have methods that implement all the string operations. General Recursive Types Some languages, such as Haskell, support general recursive types. These are defined by the set equation: R =...+(...R...R) Recursive set equations can have many solutions, but we are just interested in the least solution which is built by starting with R equal to the empty set and solving for R, and then plugging this new value for R back into the equation to get a better approximation. We keep repeating this to get better and better approximations of R. In general, the cardinality of a recursive type is infinite, even though the elements of the recursive type are finite.

18 General Recursive Types (2) Binary Trees in Haskell data BinIntTree = Empty BinIntTree Int BinIntTree BinIntTree BinIntTree 8 Empty Empty BinIntTree 8 ( BinIntTree 5 Empty Empty) ( BinIntTree 12 ( BinIntTree 10 Empty Empty) ( BinIntTree 14 ( BinIntTree 12 Empty Empty ) Empty ) ) Type Systems A type system allows a programming language to group values into types. A type system prevent a programmer from performing stupid operations such as multiplying a string by a boolean. Such operations will generate a type error. In a statically typed language each variable and expression has a fixed type. This type is either explicitly defined or inferred, but before every operation the complier can check that the operand have the correct type at compile time. In a dynamically typed language, values are typed, but variables and expressions are not. Every time an operand is computed it may result in a value of a different type. Therefore, operands can only be type checked at run time as they are computed but before the operation is performed. Most high-level languages are statically typed. Python, Prolog, Lisp, Perl and Smalltalk are dynamically typed.

19 Type Systems (2) Static typing is: More efficient than dynamic typing. Dynamic typing requires (possibly repeated) run time checks of all operands each time an operation/procedure is invoked, for example in a loop. This slows down execution. Also all values have to be tagged with their type and this requires additional memory storage. More secure. A compiler can verify that a program has no type errors. Type errors are responsible for a significant proportion of programming errors. Dynamic typing is: More flexible and necessary in applications where the type of the data is not known in advance. Type Systems (3) Python s dynamic typing in action. def respond (prompt) try : response = raw input (prompt) return int ( response ) except ValueError : return response m = respond ( Enter month: )... if m = Jan : m = 1... if m = Dec : m = 12 elif! ( isinstance (m, int ) and 1 <= m <= 12): raise DataError, month is not valid string or value

20 Type Equivalance In order to type check, we need to ask if the types of two operands, T 1 and T 2 are equivalent. There are two commonly used definitions of type equivalence. name equivalence structural equivalence T 1 is name equivalent to T 2, T 1 T 2, if T 1 and T 2 are defined in the same place. struct Date {int d, m}; struct Date yesterday ; struct Date today, tomorrow ; The variables today, yesterday and tomorrow are name equivalent in most languages. In some languages, today and tomorrow are name equivalent, though today and yesterday are not as they are defined on different lines. Java and Ada use name equivalence. Type Equivalance (2) T 1 is structurally equivalent to T 2, T 1 T 2, if T 1 and T 2 consist of the same components. struct Date {int d, m}; struct OtherDate {int d, m}; struct OtherDate yesterday ; struct Date today, tomorrow ; The variables today, yesterday and tomorrow are structurally equivalent. Algol-68, ML, C and Modula-3 use structural equivalance.

21 Expressions An expression is a programming construct that evaluates to a value. A literal denotes a fixed value of some type. For example, 2.5, false and "hello" denote a real number, a boolean and a string. A construction is an expression that build a composite value from its components. C++ structure construction enum Month {jan, feb,mar, apr, may, jun, jul, aug, sep, oct, nov, dec}; struct Date { Month m; byte d; }; struct Date today = {mar, 17}; Expressions (2) Ada array construction size : array (Month) of Integer := (feb => 28, apr jun sep nov => 30, others => 31); Haskell list construction [31, if isleapyear (year ) then 29 else 28, 31, 30, 31, 30, 31, 31, 30, 31] C++ constructions are limited in that they can only occur as initialisers in a variable declaration and the components must be literals. Java objects have a construction called the constructor and it is invoked by the new command.

22 Expressions (3) A function call, F(E), is an expression. In languages where functions are first-class values, F may be any expression that results in a function. For example in Haskell ( if... then sin else cos) (x) Operator can be thought of as denoting functions. E 1 E 2 is essentially (E 1,E 2 ) where is a binary operator. E 1 E 2 is infix notation adopted by most programming languages, and (E 1,E 2 ) is prefix notation adopted by Lisp. Some modern languages, such as C++, Ada and Haskell, recognise that E 1 E 2 is exactly equivalent to (E 1,E 2 ) and allow the programmer to write functions that define and redefine operators. Expressions (4) A conditional expression is an expression whose value depends on a condition. Examples of this are if-expressions in C, C++, Java and Haskell, and case-expression in Haskell. x > y? x : y; case month of feb > if isleapyear (year ) then 29 else 28 apr > 30 jun > 30 sep > 30 nov > 30 > 31 An iterative expression performs a computation of a series of values. In Haskell, list comprehension is an example of an iterative expression. [y y < ys, y mod 100 = 0]

23 Expressions (5) A reference to a named constant or named variable is a constant access or variable access expression. In both cases the reference results in the value of the constant or the current value of the variable. For example in Ada, pi : constant Float := ; r : Float ; area := 2 pi r evaluates the expression 2 * pi * r. The exact value that this expression will evaluate to depends on the environment of the expression. Bindings and Environments A binding is a fixed association between an identifier and a variable, value or procedure. An environment (also called a namespace) is a set of bindings. Consider the following Ada program snippet. procedure p is z: constant Integer := 0; c : Character ; procedure q is c: constant Float := 3.0e 02; b: Boolean ; begin.. (2) end q; begin... (1) end p;

24 Bindings and Environments (2) At point (1) the environment is: c: a character variable p: a procedure q: a procedure z: an integer 0 At point (2) the environment is: b: a boolean variable c: a real number 3.0e-02 p: a procedure q: a procedure z: an integer 0 Bindings and Environments (3) A bindable entity is one that can be bound to an identifier. Languages differ in what is bindable. C Java Ada types values types variables local variables values function procedures instance variables variables class variables procedures methods exceptions classes packages packages tasks

25 The scope of a declaration is the portion of the programme text over which the declaration is in effect. The scope of a binding is the portion of the programme text over which the binding is applied. In early programming languages the scope of a declaration was the whole programme. This meant writing large programmes was very awkward as every declared variable has to have a unique name. Modern programming languages limited the influence of a declaration or variable by introducing syntactic structures called blocks. Blocks A block is a construct that delimits the scope of any declaration within it. In C, the blocks are block commands ({... }), function bodies, compilation units (source files) and the whole programme itself. In Java, the blocks are block commands ({... }), method bodies, class declarations, packages and the whole programme itself. In Python, the blocks are modules, function bodies and class definitions. In Ada, blocks are block commands (declare... begin... end), procedure bodies, packages, tasks, protected objects and the whole programme itself.

26 Blocks (2) When the whole programme is the only block, the programme is said to have a monolithic block structure. Early versions of Cobol are examples of languages with monolithic block structure where every declaration is global. In languages with a flat block structure the programme is partitioned in several non-overlapping blocks. If a variable is declared in a block, its scope that block. The scope of each global variable and each procedure is the whole program. FORTRAN is an example of a flat block structure language. In a language with a nested block structure, blocks may be nested within other blocks. This is typical of Algol-like languages. C has a restricted form of nested block structure in which function bodies cannot overlap. Java allows method bodies and inner classes to be nested within a class. Ada has a truly unrestricted nested block structure. Blocks (3) declaration of x declaration of y declaration of z declaration of x declaration of y declaration of x declaration of y declaration of z declaration of z monolithic block flat block nested block

27 Visibility When an identifier I is bound to some entity X, then there is a binding occurrence of I. In the following Ada snippet: n: constant Integer := 7; the declaration of identifier n is a binding occurrence of n. When an entity X is used to which an identifier I is bound, then there is an applied occurrence of I. For each such applied occurrence we say I denotes X. In the following subsequent Ada snippet: sum := n (n 1)/2 both references to identifier n are applied occurrences of n, where n denotes 7. In a program with multiple blocks the same identifier I can be declared in multiple blocks and I will denote a different entity in each block. Visibility (2) When the same identifier, I, is declared in two nested blocks, then any applied occurrence of I in the inner block refers to the declaration of I in the inner block and not the declaration of I from the outer block. The outer declaration of I is said to be hidden by the inner declaration of I. declaration of x scope of outer declaration of x excluding the inner block declaration of x scope of inner declaration of x

28 Static vs. Dynamic Scoping A language is statically scoped if the body of a procedure is executed in the environment of the procedure s definition. Hence, we can determine the binding occurrence that corresponds to every applied occurrence of an identifier by simply examining the program s source code. A language is dynamically scoped if the body of a procedure is executed in the environment of the procedure s invocation. This environment may vary from one procedure call to another procedure call. Hence, we cannot determine which binding occurrence corresponds to each applied occurrence until run-time. Languages with dynamic scoping cannot have static typing. Most languages are statically scoped, and the few that are dynamically scoped, such as Smalltalk, have dynamic typing. Dynamic scoping tends to make programmes harder to understand and maintain. Declarations A declaration produces a binding between an identifier and an entity. Some declarations create variables. A definition is a declaration that only produces a binding. A type declaration binds an identifier to a type. There are two type of type declaration: type definition that binds an identifier to an existing type new-type declaration that binds an identifier to a new type that is not equivalent to an existing type. In C/C++ typedef char Alpha ; is a type definition as it binds Alpha to the existing type char*. Whereas, struct,enum and union are new-type declarations as they bind to new types struct Book (Alpha title, int edn}; struct Author {Alpha name, int age };

29 Declarations (2) Because Ada strictly uses name equivalence, all type declarations are new-type declarations. A constant declaration binds an identifier to a constant. They are usually of the form const I = E which binds I to the expression E (with the type if I being the type of E), or they are of the form const I T = E in which the type of I is specifically set to T. Modern languages (such as C++, Java and Ada) allow E to be evaluated at run-time. A variable declaration creates a variable and binds an identifier to that variable. Most languages allow a declaration to create several variables and bind different identifiers to them. Ada allows a variable renaming definition that binds an identifier to an exiting variable, creating an alias for the variable. pop: Integer renames population (country ); Declarations (3) A procedure definition binds an identifier to a procedure (function procedure or proper procedure). bool even ( int n) { return (n % 2 == 0); } void double ( int& n) { n = 2; return ; }

30 Composing Declarations A sequential declaration composes sub-declarations one after another. count : Integer := 0; procedure inc count is begin count := count + 1; end; A collateral declaration composes sub-declarations that are independent of each other and cannot be used until the declaration is complete. val e = and pi = ; Composing Declarations (2) A recursive declaration uses bindings that it itself has produced. Recursive declarations are not support by older languages as they were inefficient on early hardware, but they are support by most modern languages. The scope of a recursive declaration starts at the beginning of the declaration and ends with the enclosing block. void print decimal ( int n) { if (n < 0) { print ( ); print decimal ( n); } else if (n >= 10) { print decimal (n/10); print (n % ); } else print (n + 0 ); }

31 Blocks Again A block command is a command that contains a local declaration D (or a group of declarations) and a subcommand C. The binding produced by D are only in effect for the execution of C. In C/C++, a block command is {D C}. In Ada a block command is declare D begin C end. In Java, we have: if (x > y) { int z = x; x = y; y = z; } Blocks Again (2) A block expression is an expression that contains a local declaration D (or a group of declarations) and a subexpression E. The binding produced by D are only in effect for the evaluation of E. Haskell has a block expression of the form let D in E. Th calculate the area of a triangle whose sides are of length a, b and c, we can use the follow Haskell code snippet. let s = (a + b + c)/2.0 in sqrt (s (s a) (s b) (s c))