Statements:

- Variable declarations
- Expressions statments
- While loops
- Blocks: (possible empty) lists of statements enclosed in braces

Expression constructs

- Identifiers/variables
- Integer literals
- Pre-increments of identifiers (++x)
- Greater or equal than comparision (E>=E')
- Assignments of identifiers (x=E)

Expression constructs

- Identifiers/variables
- Integer literals
- Post-increments of identifiers (++x)
- less or equal than comparision (E>=E')
- Assignments of identifiers (x=E)

(a) Not valid (f is unbound)

(b) valid

(c) valid

(d) not valid (f doe snot have a function type)

(e) not valid (self application x x is not typable)

Expressions

- Identifiers/variables
- Integer literals
- post-increments of identifiers (x++)
- less-or-equal than comparisons(E<=E')
- Assignments of identifiers (x = E)

Write syntax directed *interpretation rules* for the *expression* forms above. The environment must be made explicit, as well as all possible side effects.

Expressions

- Identifiers/variables
- Integer literals
- post-increments of identifiers (x++)
- less-or-equal than comparisons(E<=E')
- Assignments of identifiers (x = E)

Write compilation schmes in pseudo code for each of the *expression *constructions above generating JVM (i. asmin assembler). It is not necessary to remember exactly the names of the instructions - only what arguments they take and how they work.

(a) not valid (f does not have a function type)

(b) valid

(c) not valid (self application xx is not typable)

(d) not valid (f is unbound)

(e) valid

Write syntax-directed *type checking *rules for the expressions below. The typing enviroment must be made explicit

- Expressions
- Subtraction -
- Multiplication *
- pre-increment of variables ++x
- Function calls x(e,...,e) with zero or more arguments
- Parenthesized expressions. (e).

Both arithmetic operations are left associative. Multiplication binds stronger than subtraction

Write syntax directed *interpretation rules *for the *statements* forms and lists below. The environment must be made explicit, as well as all possible side effects. You can assume an interpreter for expressions

- Blocks: lists of statements (possible empty) in curly brackets {}
- Variable initialization statement: a type followed by an indentifier, the equals sign, an initializing expression, and a semicolon, e.g. int x = 4
- return statemetns: an expression between keyword
*return*and a semicolon, e.g return 1;

Write compilation schemes in pseudo-code for each of the grammer constructions in. The compiler shoul output symbolic JVM instructions (i.e Jasmin assembler). It is not necessary to remember exactly the ames of the instructions - only what arguments they take and how they work.

- Statements
- Blocks: lists of statments (possible empty) in curly brackets { }
- Variable initialization: A type followed by an identifier, the equals sign, an initializing expression, and a semicolon e.g. int x = 4;
- return statements: an expression betwen keyword return, and a semicolon, e.g. return 1;

- Types
- Int

- Expressions
- Integer literals
- Subraction -
- Multiplication *
- pre-increment of variables ++x
- function calls x(e,...,e) with zero or more arguments
- parenthesized expressions (e)

Both arithemetic operations are left associative. Mutliplication binds stronger than subtraction.

##
- Statements
- Blocks: lists of statments (possible empty) in curly brackets { }
- Variable initialization: A type followed by an identifier, the equals sign, an initializing expression, and a semicolon e.g. int x = 4;
- return statements: an expression betwen keyword return, and a semicolon, e.g. return 1;

- Types
- Int

- Expressions
- Integer literals
- Subraction -
- Multiplication *
- pre-increment of variables ++x
- function calls x(e,...,e) with zero or more arguments
- parenthesized expressions (e)

- Blocks: lists of statments (possible empty) in curly brackets { }
- Variable initialization: A type followed by an identifier, the equals sign, an initializing expression, and a semicolon e.g. int x = 4;
- return statements: an expression betwen keyword return, and a semicolon, e.g. return 1;

- Int

- Integer literals
- Subraction -
- Multiplication *
- pre-increment of variables ++x
- function calls x(e,...,e) with zero or more arguments
- parenthesized expressions (e)

Both arithemetic operations are left associative. Mutliplication binds stronger than subtraction.

(a) not valid (f is unbound)

(b) valid

(c) valid

(d) not valid (*g *does not have a function type)

(e) not valid (self application x x is not typable)

Write a call-by-value interpreter for below lambda-calculus either with inference rules, or in pseudo-code or haskell

Write syntax-directed typing rules for the *expression* below. In any case, the environemnt must be made explicit

- Integer literals
- identifiers
- function calls, i.e., identifiers applied to a tuple of expressions
- Addition (+) and multiplication (*)
- less-than comparison of integer expressions (
- assignments
- parenthesized expressions

Function calls, multiplication and addition are left-associative, comparison is non-associative, assignment is right associative. Function calls binds strongest, then multiplication, then addition, then comparison, then assignment.