Syntax of Eiffel: a Brief Overview
EECS3311: Software Design Fall 2017
CHEN-WEI WANG
Commands, and Queries, and Features
● In a Java class:
○ Attributes: Data
○ Mutators: Methods that change attributes without returning
○ Accessors: Methods that access attribute values and returning
● In an Eiffel class:
○ Everything can be called a feature. ○ But if you want to be specific:
● Useattributesfordata
● Usecommandsformutators ● Usequeriesforaccessors
3 of 30
Escape Sequences
Escape sequences are special characters to be placed in your program text.
○ In Java, an escape sequence starts with a backward slash \ e.g., \n for a new line character.
○ In Eiffel, an escape sequence starts with a percentage sign % e.g., %N for a new line characgter.
See here for more escape sequences in Eiffel: https://www. eiffel.org/doc/eiffel/Eiffel%20programming% 20language%20syntax#Special_characters
2 of 30
Naming Conventions
● Cluster names: all lower-cases separated by underscores
e.g., root, model, tests, cluster number one
● Classes/Type names: all upper-cases separated by underscores
e.g., ACCOUNT, BANK ACCOUNT APPLICATION
● Feature names (attributes, commands, and queries): all
lower-cases separated by underscores
e.g., account balance, deposit into, withdraw from
4 of 30
Operators: Assignment vs. Equality
● In Java:
○ Equal sign = is for assigning a value expression to some variable.
e.g.,x = 5 * ychangesx’svalueto5 * y
This is actually controversial, since when we first learned about =, it means the mathematical equality between numbers.
○ Equal-equal == and bang-equal != are used to denote the equality and inequality.
e.g., x == 5 * y evaluates to true if x’s value is equal to the value of 5 * y, or otherwise it evaluates to false.
● In Eiffel:
○ Equal = and slash equal /= denote equality and inequality.
e.g., x = 5 * y evaluates to true if x’s value is equal to the value
of 5 * y, or otherwise it evaluates to false.
○ We use := to denote variable assignment.
e.g.,x := 5 * ychangesx’svalueto5 * y
○ Also, you are not allowed to write shorthands like x++,
5of30 justwritex := x + 1.
Method Declaration
● Command
Notice that you don’t use the return type void ● Query
deposit (amount: INTEGER) do
balance := balance + amount end
sum_of (x: INTEGER; y: INTEGER): INTEGER do
Result := x + y end
○ Input parameters are separated by semicolons ;
○ Notice that you don’t use return; instead assign the return value 7 of 30 to the pre-defined variable Result.
Attribute Declarations
● In Java, you write: int i, Account acc
● In Eiffel, you write: i: INTEGER, acc: ACCOUNT
Think of : as the set membership operator ∈:
e.g., The declaration acc: ACCOUNT means object acc is a
member of all possible instances of ACCOUNT.
6 of 30
Operators: Logical Operators (1)
● Logical operators (what you learned from EECS1090) are for combining Boolean expressions.
● In Eiffel, we have operators that EXACTLY correspond to these logical operators:
LOGIC EIFFEL Conjunction ∧ and
Disjunction
∨ or ⇒ implies
Implication Equivalence
≡ =
8 of 30
Review of Propositional Logic (1)
● A proposition is a statement of claim that must be of either true or false, but not both.
● Basic logical operands are of type Boolean: true and false.
● We use logical operators to construct compound statements.
○ Binary logical operators: conjunction (∧), disjunction (∨), implication (⇒), and equivalence (a.k.a if-and-only-if ⇐⇒ )
p p ⇐⇒ q
q
true
false
true
false
p∧q
true
false false false
false false true
○ Unary logical operator: negation (¬)¬p
p⇒q
true
false
true true
true true false false
true
p
true
false
false
true
9 of 30
p∨q
true true true false
Review of Propositional Logic (2)
● Axiom:Definitionof⇒ p⇒q≡¬p∨q
● Theorem: Identity of ⇒ true ⇒ p ≡ p
● Theorem: Zero of ⇒ false ⇒ p ≡ true
● Axiom: DeMorgan ¬(p∧q) ≡ ¬p∨¬q
¬(p∨q) ≡ ¬p∧¬q
● Axiom: Double Negation
p ≡ ¬ (¬ p)
● Theorem: Contrapositive
11 of 30
p ⇒ q ≡ ¬q ⇒ ¬p
Review of Propositional Logic: Implication
○ Writtenasp⇒q
○ Pronounced as “p implies q”
○ We call p the antecedent, assumption, or premise.
○ We call q the consequence or conclusion.
○ Compare the truth of p ⇒ q to whether a contract is honoured: p ≈
promised terms; and q ≈ obligations.
○ When the promised terms are met, then:
● Thecontractishonourediftheobligationsarefulfilled.
● Thecontractisbreachediftheobligationsarenotfulfilled. ○ When the promised terms are not met, then:
● Fulfillingtheobligation(q)ornot(¬q)doesnotbreachthecontract. q
p
p⇒q
true
false
true true
true true false false
true
false
true
false
10 of 30
Review of Predicate Logic (1)
● A predicate is a universal or existential statement about objects in some universe of disclosure.
● Unlike propositions, predicates are typically specified using variables, each of which declared with some range of values. ● We use the following symbols for common numerical ranges:
○ Z: the set of integers
○ N: the set of natural numbers
● Variable(s) in a predicate may be quantified:
○ Universal quantification :
All values that a variable may take satisfy certain property.
○
e.g., Given that i is a natural number, i is always non-negative. Existential quantification :
Some value that a variable may take satisfies certain property.
e.g., Given that i is an integer, i can be negative. 12 of 30
Review of Predicate Logic (2.1)
● A universal quantification has the form (∀X R ● P) ○ X is a list of variable declarations
○ R is a constraint on ranges of declared variables ○ P is a property
○(∀XR●P)≡(∀X ●R⇒P)
e.g.,(∀X True ● P)≡(∀X ● True⇒P)≡(∀X ● P)
e.g.,(∀X False ● P)≡(∀X ● False⇒P)≡(∀X ● True)≡True ● For all (combinations of) values of variables declared in X that
satisfies R, it is the case that P is satisfied.
○ ∀i i ∈ N ● i ≥ 0 [true] ○ ∀i i ∈ Z ● i ≥ 0 [false] ○ ∀i,ji∈Z∧j∈Z ● i
● The range constraint of a variable may be moved to where the variable is declared.
○ ∀i ∶ N ● i ≥ 0
○ ∀i ∶ Z ● i ≥ 0
○ ∀i,j∶Z ● i
Predicate Logic (3)
● Conversion between ∀ and ∃
( ∀ X R ● P ) ⇐⇒ ¬ ( ∃ X ● R ⇒ ¬ P )
( ∃ X R ● P ) ⇐⇒ ¬ ( ∀ X ● R ⇒ ¬ P ) ● Range Elimination
15 of 30
( ∀ X R ● P ) ⇐⇒ ( ∀ X ● R ⇒ P ) ( ∃ X R ● P ) ⇐⇒ ( ∃ X ● R ∧ P )
Review of Predicate Logic (2.2)
● An existential quantification has the form (∃X R ● P) ○ X is a list of variable declarations
○ R is a constraint on ranges of declared variables ○ P is a property
○(∃XR●P)≡(∃X ●R∧P)
e.g.,(∃X True ● P)≡(∃X ● True∧P)≡(∀X ● P)
e.g.,(∃X False ● P)≡(∃X ● False∧P)≡(∃X ● False)≡False ● There exists a combination of values of variables declared in X
that satisfies R and P.
○ ∃i i ∈ N ● i ≥ 0 [true] ○ ∃i i ∈ Z ● i ≥ 0 [true] ○ ∃i,ji∈Z∧j∈Z ● i
● The range constraint of a variable may be moved to where the variable is declared.
○ ∃i ∶ N ● i ≥ 0
○ ∃i ∶ Z ● i ≥ 0
○ ∃i,j∶Z ● i
Operators: Logical Operators (2)
● How about Java?
○ Java does not have an operator for logical implication.
○ The == operator can be used for logical equivalence.
○ The && and || operators only approximate conjunction and
disjunction, due to the short-circuit effect (SCE):
● When evaluating e1 && e2, if e1 already evaluates to false, then e1
will not be evaluated.
e.g., In (y != 0) && (x / y > 10), the SCE guards the division against division-by-zero error.
● When evaluating e1 || e2, if e1 already evaluates to true, then e1 will not be evaluated.
e.g., In (y == 0) || (x / y > 10), the SCE guards the division against division-by-zero error.
○ However, in math, we always evaluate both sides.
● In Eiffel, we also have the version of operators with SCE:
16 of 30
short-circuit conjunction short-circuit disjunction
Java && || Eiffel and then or else
Operators: Division and Modulo
Division
Java 20 / 3is6 Eiffel 20 // 3is6
Modulo (Remainder)
20 % 3is2 20 \\ 3is2
17 of 30
Class Constructor Declarations (1)
● In Eiffel, constructors are just commands that have been explicitly declared as creation features:
class BANK_ACCOUNT
— List names commands that can be used as constru create
make
feature — Commands make (b: INTEGER)
do balance := b end make2
do balance := 10 end end
● Only the command make can be used as a constructor.
● Command make2 is not declared explicitly, so it cannot be used 19 oaf 3s0 a constructor.
ctors
Class Declarations
● In Java:
● In Eiffel:
class BankAccount {
/* attributes and methods */
}
class BANK_ACCOUNT
/* attributes, commands, and queries */
end
18 of 30
Creations of Objects (1)
● In Java, we use a constructor Accont(int b) by:
○ Writing Account acc = new Account(10) to create a named
object acc
○ Writing new Account(10) to create an anonymous object
● In Eiffel, we use a creation feature (i.e., a command explicitly declared under create) make (int b) in class ACCOUNT by:
○ Writing create {ACCOUNT} acc.make (10) to create a named object acc
○ Writing create {ACCOUNT}.make (10) to create an anonymous object
● Writing
is really equivalent to writing
20 of 30
create {ACCOUNT} acc.make (10)
acc := create {ACCOUNT}.make (10)
Selections
if B1 then — B1
— do something
elseif B2 then
— B2∧(¬B1)
— do something else
— default action
end
else
— (¬B1)∧(¬B2)
21 of 30
Loops (2)
In Eiffel, the Boolean conditions you need to specify for loops are exit conditions (logical negations of the stay conditions).
print_stuffs
local
i: INTEGER
do from
i := 0 until
i >= 10 loop
print (i)
i := i + 1
end — end loop
end — end command 23 of 30
Don’t put () after a command or query with no input parameters.
○
○ Local variables must all be declared in the beginning.
Loops (1)
● In Java, the Boolean conditions in for and while loops are stay conditions.
void printStuffs() { int i = 0;
while(i < 10) {
System.out.println(i);
i = i + 1; }
}
● In the above Java loop, we stay in the loop aslongasi < 10istrue.
● In Eiffel, we think the opposite: we exit the loop
assoonasi >= 10istrue. 22 of 30
Library Data Structures
Enter a DS name. Explore supported features.
24 of 30
Data Structures: Arrays
● Creating an empty array:
○ This creates an array of lower and upper indices 1 and 0.
local a: ARRAY[INTEGER]
do create {ARRAY[INTEGER]} a.make empty
○ Size of array a: .
● Typical loop structure to iterate through an array:
a.upper – a.lower + 1
local
a: ARRAY[INTEGER] i, j: INTEGER
do
…
from
j := a.lower until
j > a.upper do
i := a [j]
j := j + 1
end
25 of 30
Data Structures: Linked Lists (2)
● Creating an empty linked list:
● Typical loop structure to iterate through a linked list:
local
list: LINKED_LIST[INTEGER] i: INTEGER
do
…
from
list.start until
list.after do
i := list.item
list.forth end
27 of 30
local
list: LINKED_LIST[INTEGER]
do
create {LINKED_LIST[INTEGER]} list.make
Data Structures: Linked Lists (1)
26 of 30
Using across for Quantifications ● across … as … … end
all
A Boolean expression acting as a universal quantification (∀) 1 local
2 3 4 5 6 7 8 9
10 11
allPositive: BOOLEAN
a: ARRAY[INTEGER] do
…
Result :=
across
a.lower |..| a.upper as i all
a [i.item] > 0 end
○ L8: a.lower |..| a.upper denotes a list of integers. ○ L8: as i declares a list cursor for this list.
○ L10: i.item denotes the value pointed to by cursor i.
● L9: Changing the keyword all to some makes it act like an
existential quantification ∃. 28 of 30
Index (1) Escape Sequences
Commands, Queries, and Features Naming Conventions
Operators: Assignment vs. Equality Attribute Declarations
Method Declaration
Operators: Logical Operators (1)
Review of Propositional Logic (1)
Review of Propositional Logic: Implication Review of Propositional Logic (2)
Review of Predicate Logic (1)
Review of Predicate Logic (2.1)
Review of Predicate Logic (2.2)
Predicate Logic (3)
29 of 30
Index (2)
Operators: Logical Operators (2)
Operators: Division and Modulo Class Declarations
Class Constructor Declarations (1) Creations of Objects (1) Selections
Loops (1)
Loops (2)
Library Data Structures
Data Structures: Arrays
Data Structures: Linked Lists (1) Data Structures: Linked Lists (2)
Using across to for Quantifications 30 of 30