Eiffel (programming language)

Design goals

Eiffel emphasizes declarative statements over procedural code and attempts to eliminate the need for bookkeeping instructions.

Eiffel shuns coding tricks or techniques intended as program optimization hints to a compiler. The goals are to make the code more readable, and to facilitate concentrating on the important aspects of a program without getting bogged down in implementation details. Eiffel's simplicity is intended to promote simple, extensible, reusable, and reliable answers to computing problems. Compilers for computer programs written in Eiffel provide extensive optimizing techniques, such as automatic inline expansion (inlining), that eliminate part of the optimizing burden.

Background

Eiffel was originally developed by Eiffel Software, a company founded by Bertrand Meyer. Object-Oriented Software Construction contains a detailed treatment of the concepts and theory of the object technology that led to Eiffel's design.

The design goal behind the Eiffel language, libraries, and programming methods is to enable programmers to create reliable, reusable software modules. Eiffel supports multiple inheritance, genericity, polymorphism, encapsulation, type-safe conversions, and parameter covariance. Eiffel's most important contribution to software engineering is design by contract (DbC), in which assertions, preconditions, postconditions, and class invariants are employed to help ensure program correctness without sacrificing efficiency.

Eiffel's design is based on object-oriented programming theory, with only minor influence of other programming paradigms or concern for support of legacy code. Eiffel formally supports abstract data types. Under Eiffel's design, a software text should be able to reproduce its design documentation from the text itself, using a formalized implementation of the "Abstract Data Type".

Implementations and environments

EiffelStudio is an integrated development environment available under either an open source or a commercial license. It offers an object-oriented environment for software engineering, compiling to either C or .NET. EiffelEnvision is a plug-in for Microsoft Visual Studio that allows users to edit, compile, and debug Eiffel projects from within the Microsoft Visual Studio IDE. Five other open source implementations are available: "The Eiffel Compiler" tecomp; Gobo Eiffel; SmartEiffel, the GNU implementation, based on an older version of the language; LibertyEiffel, based on the SmartEiffel compiler; and Visual Eiffel.

Several other programming languages incorporate elements first introduced in Eiffel. Sather, for example, was originally based on Eiffel but has since diverged, and now includes several functional programming features. The interactive-teaching language Blue, forerunner of BlueJ, is also Eiffel-based. The Apple Media Tool includes an Eiffel-based Apple Media Language.

Specifications and standards

The Eiffel language definition is an international standard of the ISO. The standard was developed by ECMA International, which first approved the standard on 21 June 2005 as Standard ECMA-367, Eiffel: Analysis, Design and Programming Language. In June 2006, ECMA and ISO adopted the second version. In November 2006, ISO first published that version. The standard can be found and used free of charge on the ECMA site. The ISO version is identical in all respects except formatting.

Eiffel Software, "The Eiffel Compiler" tecomp and Eiffel-library-developer Gobo have committed to implementing the standard; Eiffel Software's EiffelStudio 6.1 and "The Eiffel Compiler" tecomp implement some of the major new mechanisms—in particular, inline agents, assigner commands, bracket notation, non-conforming inheritance, and attached types. The SmartEiffel team has turned away from this standard to create its own version of the language, which they believe to be closer to the original style of Eiffel. Object Tools has not disclosed whether future versions of its Eiffel compiler will comply with the standard. LibertyEiffel implements a dialect somewhere in between the SmartEiffel language and the standard.

The standard cites the following, predecessor Eiffel-language specifications:

• Bertrand Meyer: Eiffel: The Language, Prentice Hall, second printing, 1992 (first printing: 1991)
• Bertrand Meyer: Standard Eiffel (revision of preceding entry), ongoing, 1997–present, at Bertrand Meyer's ETL3 page, and
• Bertrand Meyer: Object-Oriented Software Construction, Prentice Hall: first edition, 1988; second edition, 1997.
• Bertrand Meyer: Touch of Class: Learning to Program Well with Objects and Contracts, Springer-Verlag, 2009 ISBN 978-3-540-92144-8 lxiv + 876 pages Full-color printing, numerous color photographs

The current version of the standard from June 2006 contains some inconsistencies (e.g. covariant redefinitions). The ECMA committee has not yet announced any timeline and direction on how to resolve the inconsistencies.

Syntax and semantics

Overall structure

An Eiffel "system" or "program" is a collection of classes. Above the level of classes, Eiffel defines cluster, which is essentially a group of classes, and possibly of subclusters (nested clusters). Clusters are not a syntactic language construct, but rather a standard organizational convention. Typically an Eiffel program will be organized with each class in a separate file, and each cluster in a directory containing class files. In this organization, subclusters are subdirectories. For example, under standard organizational and casing conventions, x.e might be the name of a file that defines a class called X.

A class contains features, which are similar to "routines", "members", "attributes" or "methods" in other object-oriented programming languages. A class also defines its invariants, and contains other properties, such as a "notes" section for documentation and metadata. Eiffel's standard data types, such as INTEGER, STRING and ARRAY, are all themselves classes.

Every system must have a class designated as "root", with one of its creation procedures designated as "root procedure". Executing a system consists of creating an instance of the root class and executing its root procedure. Generally, doing so creates new objects, calls new features, and so on.

Eiffel has five basic executable instructions: assignment, object creation, routine call, condition, and iteration. Eiffel's control structures are strict in enforcing structured programming: every block has exactly one entry and exactly one exit.

Scoping

Unlike many object-oriented languages, but like Smalltalk, Eiffel does not permit any assignment into attributes of objects, except within the features of an object, which is the practical application of the principle of information hiding or data abstraction, requiring formal interfaces for data mutation. To put it in the language of other object-oriented programming languages, all Eiffel attributes are "protected", and "setters" are needed for client objects to modify values. An upshot of this is that "setters" can and normally do, implement the invariants for which Eiffel provides syntax.

While Eiffel does not allow direct access to the features of a class by a client of the class, it does allow for the definition of an "assigner command", such as:

<span id="mwxA"></span><span class="linenos" data-line="1" id="mwxQ"></span><span class="w" id="mwxg"> </span><span class="n" id="mwxw">some_attribute</span><span class="p" id="mwyA">:</span><span class="w" id="mwyQ"> </span><span class="nc" id="mwyg">SOME_TYPE</span><span class="w" id="mwyw"> </span><span class="kr" id="mwzA">assign</span><span class="w" id="mwzQ"> </span><span class="n" id="mwzg">set_some_attribute</span> <span class="linenos" data-line="2" id="mwzw"></span><span class="w" id="mw0A"> </span> <span class="linenos" data-line="3" id="mw0Q"></span><span class="w" id="mw0g"> </span><span class="n" id="mw0w">set_some_attribute</span><span class="w" id="mw1A"> </span><span class="p" id="mw1Q">(</span><span class="n" id="mw1g">v</span><span class="p" id="mw1w">:</span><span class="w" id="mw2A"> </span><span class="nc" id="mw2Q">VALUE_TYPE</span><span class="p" id="mw2g">)</span> <span class="linenos" data-line="4" id="mw2w"></span><span class="w" id="mw3A"> </span><span class="c1" id="mw3Q">-- Set value of some_attribute to `v'.</span> <span class="linenos" data-line="5" id="mw3g"></span><span class="w" id="mw3w"> </span><span class="kr" id="mw4A">do</span> <span class="linenos" data-line="6" id="mw4Q"></span><span class="w" id="mw4g"> </span><span class="n" id="mw4w">some_attribute</span><span class="w" id="mw5A"> </span><span class="o" id="mw5Q">:=</span><span class="w" id="mw5g"> </span><span class="n" id="mw5w">v</span> <span class="linenos" data-line="7" id="mw6A"></span><span class="w" id="mw6Q"> </span><span class="kr" id="mw6g">end</span>

While a slight bow to the overall developer community to allow something looking like direct access (e.g. thereby breaking the Information Hiding Principle), the practice is dangerous as it hides or obfuscates the reality of a "setter" being used. In practice, it is better to redirect the call to a setter rather than implying a direct access to a feature like some_attribute as in the example code above.

Unlike other languages, having notions of "public", "protected", "private" and so on, Eiffel uses an exporting technology to more precisely control the scoping between client and supplier classes. Feature visibility is checked statically at compile-time. For example, (below), the {NONE} is similar to "protected" in other languages. Scope applied this way to a "feature set" (e.g. everything below the 'feature' keyword to either the next feature set keyword or the end of the class) can be changed in descendant classes using the "export" keyword.

<span id="mw8w"></span><span class="linenos" data-line="1" id="mw9A"></span><span class="kr" id="mw9Q">feature</span><span class="w" id="mw9g"> </span><span class="p" id="mw9w">{</span><span class="kr" id="mw-A">NONE</span><span class="p" id="mw-Q">}</span><span class="w" id="mw-g"> </span><span class="c1" id="mw-w">-- Initialization</span> <span class="linenos" data-line="2" id="mw_A"></span><span class="w" id="mw_Q"> </span><span class="n" id="mw_g">default_create</span> <span class="linenos" data-line="3" id="mw_w"></span><span class="w" id="mwAQA"> </span><span class="c1" id="mwAQE">-- Initialize a new `zero' decimal instance.</span> <span class="linenos" data-line="4" id="mwAQI"></span><span class="w" id="mwAQM"> </span><span class="kr" id="mwAQQ">do</span> <span class="linenos" data-line="5" id="mwAQU"></span><span class="w" id="mwAQY"> </span><span class="n" id="mwAQc">make_zero</span> <span class="linenos" data-line="6" id="mwAQg"></span><span class="w" id="mwAQk"> </span><span class="kr" id="mwAQo">end</span>

Alternatively, the lack of a {x} export declaration implies {ANY} and is similar to the "public" scoping of other languages.

<span id="mwARA"></span><span class="kr" id="mwARE">feature</span><span class="w" id="mwARI"> </span><span class="c1" id="mwARM">-- Constants</span>

Finally, scoping can be selectively and precisely controlled to any class in the Eiffel project universe, such as:

<span id="mwARc"></span><span class="kr" id="mwARg">feature</span><span class="w" id="mwARk"> </span><span class="p" id="mwARo">{</span><span class="nc" id="mwARs">DECIMAL</span><span class="p" id="mwARw">,</span><span class="w" id="mwAR0"> </span><span class="nc" id="mwAR4">DCM_MA_DECIMAL_PARSER</span><span class="p" id="mwAR8">,</span><span class="w" id="mwASA"> </span><span class="nc" id="mwASE">DCM_MA_DECIMAL_HANDLER</span><span class="p" id="mwASI">}</span><span class="w" id="mwASM"> </span><span class="c1" id="mwASQ">-- Access</span>

Here, the compiler will allow only the classes listed between the curly braces to access the features within the feature group (e.g. DECIMAL, DCM_MA_DECIMAL_PARSER, DCM_MA_DECIMAL_HANDLER).

"Hello, world!"

A programming language's look and feel is often conveyed using a "Hello, world!" program. Such a program written in Eiffel might be:

<span id="mwAS4"></span><span class="kr" id="mwAS8">class</span> <span class="w" id="mwATA"> </span><span class="nc" id="mwATE">HELLO_WORLD</span> <span class="kr" id="mwATI">create</span> <span class="w" id="mwATM"> </span><span class="n" id="mwATQ">make</span> <span class="kr" id="mwATU">feature</span> <span class="w" id="mwATY"> </span><span class="n" id="mwATc">make</span> <span class="w" id="mwATg"> </span><span class="kr" id="mwATk">do</span> <span class="w" id="mwATo"> </span><span class="n" id="mwATs">print</span><span class="w" id="mwATw"> </span><span class="p" id="mwAT0">(</span><span class="s" id="mwAT4">"Hello, world!%N"</span><span class="p" id="mwAT8">)</span> <span class="w" id="mwAUA"> </span><span class="kr" id="mwAUE">end</span> <span class="kr" id="mwAUI">end</span>

This program contains the class HELLO_WORLD. The constructor (create routine) for the class, named make, invokes the print system library routine to write a Hello, world! message to the output.

Design by contract

The concept of Design by Contract is central to Eiffel. The contracts assert what must be true before a routine is executed (precondition) and what must hold to be true after the routine finishes (post-condition). Class Invariant contracts define what assertions must hold true both before and after any feature of a class is accessed (both routines and attributes). Moreover, contracts codify into executable code developer and designers assumptions about the operating environment of the features of a class or the class as a whole by means of the invariant.

The Eiffel compiler is designed to include the feature and class contracts in various levels. EiffelStudio, for example, executes all feature and class contracts during execution in the "Workbench mode." When an executable is created, the compiler is instructed by way of the project settings file (e.g. ECF file) to either include or exclude any set of contracts. Thus, an executable file can be compiled to either include or exclude any level of contract, thereby bringing along continuous levels of unit and integration testing. Moreover, contracts can be continually and methodically exercised by way of the Auto-Test feature found in EiffelStudio.

The Design by Contract mechanisms are tightly integrated with the language and guide redefinition of features in inheritance:

• Routine precondition: The precondition may only be weakened by inheritance; any call that meets the requirements of the ancestor meets those of the descendant.
• Routine postcondition: The postcondition can only be strengthened by inheritance; any result guaranteed by the ancestor is still provided by the descendant.
• Class invariant: Conditions that must hold true after the object's creation and after any call to an exported class routine. Because the invariant is checked so often, it makes it simultaneously the most expensive and most powerful form of condition or contract.

In addition, the language supports a "check instruction" (a kind of "assert"), loop invariants, and loop variants (which guarantee loop termination).

Void-safe capability

Void-safe ability, like static typing, is another facility for improving software quality. Void-safe software is protected from runtime errors caused by calls to void references, and therefore will be more reliable than software in which calls to void targets can occur. The analogy to static typing is a useful one. Void-safe ability can be seen as an extension to the type system, or a step beyond static typing, because the mechanism for ensuring void safety is integrated into the type system.

The guard against void target calls can be seen by way of the notion of attachment and (by extension) detachment (e.g. detachable keyword). The void-safe facility can be seen in a short re-work of the example code used above:

<span id="mwAV8"></span><span class="w" id="mwAWA"> </span><span class="n" id="mwAWE">some_attribute</span><span class="p" id="mwAWI">:</span><span class="w" id="mwAWM"> </span><span class="kr" id="mwAWQ">detachable</span><span class="w" id="mwAWU"> </span><span class="nc" id="mwAWY">SOME_TYPE</span> <span class="w" id="mwAWc"> </span> <span class="w" id="mwAWg"> </span><span class="n" id="mwAWk">use_some_attribute</span> <span class="w" id="mwAWo"> </span><span class="c1" id="mwAWs">-- Set value of some_attribute to `v'.</span> <span class="w" id="mwAWw"> </span><span class="kr" id="mwAW0">do</span> <span class="w" id="mwAW4"> </span><span class="kr" id="mwAW8">if</span><span class="w" id="mwAXA"> </span><span class="kr" id="mwAXE">attached</span><span class="w" id="mwAXI"> </span><span class="n" id="mwAXM">some_attribute</span><span class="w" id="mwAXQ"> </span><span class="kr" id="mwAXU">as</span><span class="w" id="mwAXY"> </span><span class="n" id="mwAXc">l_attribute</span><span class="w" id="mwAXg"> </span><span class="kr" id="mwAXk">then</span> <span class="w" id="mwAXo"> </span><span class="n" id="mwAXs">do_something</span><span class="w" id="mwAXw"> </span><span class="p" id="mwAX0">(</span><span class="n" id="mwAX4">l_attribute</span><span class="p" id="mwAX8">)</span> <span class="w" id="mwAYA"> </span><span class="kr" id="mwAYE">end</span> <span class="w" id="mwAYI"> </span><span class="kr" id="mwAYM">end</span> <span class="w" id="mwAYQ"> </span> <span class="w" id="mwAYU"> </span><span class="n" id="mwAYY">do_something</span><span class="w" id="mwAYc"> </span><span class="p" id="mwAYg">(</span><span class="n" id="mwAYk">a_value</span><span class="p" id="mwAYo">:</span><span class="w" id="mwAYs"> </span><span class="nc" id="mwAYw">SOME_TYPE</span><span class="p" id="mwAY0">)</span> <span class="w" id="mwAY4"> </span><span class="c1" id="mwAY8">-- Do something with `a_value'.</span> <span class="w" id="mwAZA"> </span><span class="kr" id="mwAZE">do</span> <span class="w" id="mwAZI"> </span><span class="p" id="mwAZM">...</span><span class="w" id="mwAZQ"> </span><span class="n" id="mwAZU">doing</span><span class="w" id="mwAZY"> </span><span class="n" id="mwAZc">something</span><span class="w" id="mwAZg"> </span><span class="n" id="mwAZk">with</span><span class="w" id="mwAZo"> </span><span class="err" id="mwAZs">`</span><span class="n" id="mwAZw">a_value</span><span class="err" id="mwAZ0">'</span><span class="w" id="mwAZ4"> </span><span class="p" id="mwAZ8">...</span> <span class="w" id="mwAaA"> </span><span class="kr" id="mwAaE">end</span>

The code example above shows how the compiler can statically address the reliability of whether some_attribute will be attached or detached at the point it is used. Notably, the attached keyword allows for an "attachment local" (e.g. l_attribute), which is scoped to only the block of code enclosed by the if-statement construct. Thus, within this small block of code, the local variable (e.g. l_attribute) can be statically guaranteed to be non-void (i.e. void safe).

Features: commands and queries

The primary characteristic of a class is that it defines a set of features: as a class represents a set of run-time objects, or "instances", a feature is an operation on these objects. There are two kinds of features: queries and commands. A query provides information about an instance. A command modifies an instance.

The command-query distinction is important to the Eiffel method. In particular:

• Uniform-Access Principle: from the point of view of a software client making a call to a class feature, whether a query is an attribute (field value) or a function (computed value) should not make any difference. For example, a_vehicle.speed could be an attribute accessed on the object a_vehicle, or it could be computed by a function that divides distance by time. The notation is the same in both cases, so that it is easy to change the class's implementation without affecting client software.
• Command-Query Separation Principle: Queries must not modify the instance. This is not a language rule but a methodological principle. So in good Eiffel style, one does not find "get" functions that change something and return a result; instead there are commands (procedures) to change objects, and queries to obtain information about the object, resulting from preceding changes.

Overloading

Eiffel does not allow argument overloading. Each feature name within a class always maps to a specific feature within the class. One name, within one class, means one thing. This design choice helps the readability of classes, by avoiding a cause of ambiguity about which routine will be invoked by a call. It also simplifies the language mechanism; in particular, this is what makes Eiffel's multiple inheritance mechanism possible.

Names can, of course, be reused in different classes. For example, the feature plus (along with its infix alias "+") is defined in several classes: INTEGER, REAL, STRING, etc.

Genericity

A generic class is a class that varies by type (e.g. LIST [PHONE], a list of phone numbers; ACCOUNT [G->ACCOUNT_TYPE], allowing for ACCOUNT [SAVINGS] and ACCOUNT [CHECKING], etc.). Classes can be generic, to express that they are parameterized by types. Generic parameters appear in square brackets:

<span id="mwAc8"></span><span class="kr" id="mwAdA">class</span><span class="w" id="mwAdE"> </span><span class="nc" id="mwAdI">LIST</span><span class="w" id="mwAdM"> </span><span class="o" id="mwAdQ">[</span><span class="nc" id="mwAdU">G</span><span class="o" id="mwAdY">]</span><span class="w" id="mwAdc"> </span><span class="p" id="mwAdg">...</span>

G is known as a "formal generic parameter". (Eiffel reserves "argument" for routines, and uses "parameter" only for generic classes.) With such a declaration G represents within the class an arbitrary type; so a function can return a value of type G, and a routine can take an argument of that type:

<span id="mwAeI"></span><span class="n" id="mwAeM">item</span><span class="p" id="mwAeQ">:</span><span class="w" id="mwAeU"> </span><span class="nc" id="mwAeY">G</span><span class="w" id="mwAec"> </span><span class="kr" id="mwAeg">do</span><span class="w" id="mwAek"> </span><span class="p" id="mwAeo">...</span><span class="w" id="mwAes"> </span><span class="kr" id="mwAew">end</span> <span class="n" id="mwAe0">put</span><span class="w" id="mwAe4"> </span><span class="p" id="mwAe8">(</span><span class="n" id="mwAfA">x</span><span class="p" id="mwAfE">:</span><span class="w" id="mwAfI"> </span><span class="nc" id="mwAfM">G</span><span class="p" id="mwAfQ">)</span><span class="w" id="mwAfU"> </span><span class="kr" id="mwAfY">do</span><span class="w" id="mwAfc"> </span><span class="p" id="mwAfg">...</span><span class="w" id="mwAfk"> </span><span class="kr" id="mwAfo">end</span>

The LIST [INTEGER] and LIST [WORD] are "generic derivations" of this class. Permitted combinations (with n: INTEGER, w: WORD, il: LIST [INTEGER], wl: LIST [WORD]) are:

<span id="mwAgQ"></span><span class="n" id="mwAgU">n</span><span class="w" id="mwAgY"> </span><span class="o" id="mwAgc">:=</span><span class="w" id="mwAgg"> </span><span class="n" id="mwAgk">il</span><span class="p" id="mwAgo">.</span><span class="n" id="mwAgs">item</span> <span class="n" id="mwAgw">wl</span><span class="p" id="mwAg0">.</span><span class="n" id="mwAg4">put</span><span class="w" id="mwAg8"> </span><span class="p" id="mwAhA">(</span><span class="n" id="mwAhE">w</span><span class="p" id="mwAhI">)</span>

INTEGER and WORD are the "actual generic parameters" in these generic derivations.

It is also possible to have 'constrained' formal parameters, for which the actual parameter must inherit from a given class, the "constraint". For example, in

<span id="mwAhk"></span><span class="w" id="mwAho"> </span><span class="kr" id="mwAhs">class</span><span class="w" id="mwAhw"> </span><span class="nc" id="mwAh0">HASH_TABLE</span><span class="w" id="mwAh4"> </span><span class="o" id="mwAh8">[</span><span class="nc" id="mwAiA">G</span><span class="p" id="mwAiE">,</span><span class="w" id="mwAiI"> </span><span class="nc" id="mwAiM">KEY</span><span class="w" id="mwAiQ"> </span><span class="o" id="mwAiU">-></span><span class="w" id="mwAiY"> </span><span class="nc" id="mwAic">HASHABLE</span><span class="o" id="mwAig">]</span>

a derivation HASH_TABLE [INTEGER, STRING] is valid only if STRING inherits from HASHABLE (as it indeed does in typical Eiffel libraries). Within the class, having KEY constrained by HASHABLE means that for x: KEY it is possible to apply to x all the features of HASHABLE, as in x.hash_code.

Inheritance basics

To inherit from one or more others, a class will include an inherit clause at the beginning:

<span id="mwAjg"></span><span class="kr" id="mwAjk">class</span><span class="w" id="mwAjo"> </span><span class="nc" id="mwAjs">C</span><span class="w" id="mwAjw"> </span><span class="kr" id="mwAj0">inherit</span> <span class="w" id="mwAj4"> </span><span class="nc" id="mwAj8">A</span> <span class="w" id="mwAkA"> </span><span class="nc" id="mwAkE">B</span> <span class="c1" id="mwAkI">-- ... Rest of class declaration ...</span>

The class may redefine (override) some or all of the inherited features. This must be explicitly announced at the beginning of the class through a redefine subclause of the inheritance clause, as in

<span id="mwAkc"></span><span class="kr" id="mwAkg">class</span><span class="w" id="mwAkk"> </span><span class="nc" id="mwAko">C</span><span class="w" id="mwAks"> </span><span class="kr" id="mwAkw">inherit</span> <span class="w" id="mwAk0"> </span><span class="nc" id="mwAk4">A</span> <span class="w" id="mwAk8"> </span><span class="kr" id="mwAlA">redefine</span><span class="w" id="mwAlE"> </span><span class="n" id="mwAlI">f</span><span class="p" id="mwAlM">,</span><span class="w" id="mwAlQ"> </span><span class="n" id="mwAlU">g</span><span class="p" id="mwAlY">,</span><span class="w" id="mwAlc"> </span><span class="n" id="mwAlg">h</span><span class="w" id="mwAlk"> </span><span class="kr" id="mwAlo">end</span> <span class="w" id="mwAls"> </span><span class="nc" id="mwAlw">B</span> <span class="w" id="mwAl0"> </span><span class="kr" id="mwAl4">redefine</span><span class="w" id="mwAl8"> </span><span class="n" id="mwAmA">u</span><span class="p" id="mwAmE">,</span><span class="w" id="mwAmI"> </span><span class="n" id="mwAmM">v</span><span class="w" id="mwAmQ"> </span><span class="kr" id="mwAmU">end</span>

See for a complete discussion of Eiffel inheritance.

Deferred classes and features

Classes may be defined with deferred class rather than with class to indicate that the class may not be directly instantiated. Non-instantiatable classes are called abstract classes in some other object-oriented programming languages. In Eiffel parlance, only an "effective" class can be instantiated (it may be a descendant of a deferred class). A feature can also be deferred by using the deferred keyword in place of a do clause. If a class has any deferred features it must be declared as deferred; however, a class with no deferred features may nonetheless itself be deferred.

Deferred classes play some of the same role as interfaces in languages such as Java, though many object-oriented programming theorists believe interfaces are themselves largely an answer to Java's lack of multiple inheritance (which Eiffel has).

Renaming

A class that inherits from one or more others gets all its features, by default under their original names. It may, however, change their names through rename clauses. This is required in the case of multiple inheritance if there are name clashes between inherited features; without renaming, the resulting class would violate the no-overloading principle noted above and hence would be invalid.

Tuples

Tuples types may be viewed as a simple form of class, providing only attributes and the corresponding "setter" procedure. A typical tuple type reads

<span id="mwAoM"></span><span class="w" id="mwAoQ"> </span><span class="nc" id="mwAoU">TUPLE</span><span class="w" id="mwAoY"> </span><span class="o" id="mwAoc">[</span><span class="n" id="mwAog">name</span><span class="p" id="mwAok">:</span><span class="w" id="mwAoo"> </span><span class="nc" id="mwAos">STRING</span><span class="p" id="mwAow">;</span><span class="w" id="mwAo0"> </span><span class="n" id="mwAo4">weight</span><span class="p" id="mwAo8">:</span><span class="w" id="mwApA"> </span><span class="nc" id="mwApE">REAL</span><span class="p" id="mwApI">;</span><span class="w" id="mwApM"> </span><span class="n" id="mwApQ">date</span><span class="p" id="mwApU">:</span><span class="w" id="mwApY"> </span><span class="nc" id="mwApc">DATE</span><span class="o" id="mwApg">]</span>

and could be used to describe a simple notion of birth record if a class is not needed. An instance of such a tuple is simply a sequence of values with the given types, given in brackets, such as

<span id="mwApw"></span><span class="w" id="mwAp0"> </span><span class="o" id="mwAp4">[</span><span class="s" id="mwAp8">"Brigitte"</span><span class="p" id="mwAqA">,</span><span class="w" id="mwAqE"> </span><span class="mf" id="mwAqI">3.5</span><span class="p" id="mwAqM">,</span><span class="w" id="mwAqQ"> </span><span class="n" id="mwAqU">Last_night</span><span class="o" id="mwAqY">]</span>

Components of such a tuple can be accessed as if the tuple tags were attributes of a class, for example if t has been assigned the above tuple then t.weight has value 3.5.

Thanks to the notion of assigner command (see below), dot notation can also be used to assign components of such a tuple, as in

<span id="mwAq0"></span><span class="w" id="mwAq4"> </span><span class="n" id="mwAq8">t</span><span class="p" id="mwArA">.</span><span class="n" id="mwArE">weight</span><span class="w" id="mwArI"> </span><span class="o" id="mwArM">:=</span><span class="w" id="mwArQ"> </span><span class="n" id="mwArU">t</span><span class="p" id="mwArY">.</span><span class="n" id="mwArc">weight</span><span class="w" id="mwArg"> </span><span class="o" id="mwArk">+</span><span class="w" id="mwAro"> </span><span class="mf" id="mwArs">0.5</span>

The tuple tags are optional, so that it is also possible to write a tuple type as TUPLE [STRING, REAL, DATE]. (In some compilers this is the only form of tuple, as tags were introduced with the ECMA standard.)

The precise specification of e.g. TUPLE [A, B, C] is that it describes sequences of at least three elements, the first three being of types A, B, C respectively. As a result, TUPLE [A, B, C] conforms to (may be assigned to) TUPLE [A, B], to TUPLE [A] and to TUPLE (without parameters), the topmost tuple type to which all tuple types conform.

Agents

Eiffel's "agent" mechanism wraps operations into objects. This mechanism can be used for iteration, event-driven programming, and other contexts in which it is useful to pass operations around the program structure. Other programming languages, especially ones that emphasize functional programming, allow a similar pattern using continuations, closures, or generators; Eiffel's agents emphasize the language's object-oriented paradigm, and use a syntax and semantics similar to code blocks in Smalltalk and Ruby.

For example, to execute the my_action block for each element of my_list, one would write:

<span id="mwAtY"></span><span class="w" id="mwAtc"> </span><span class="n" id="mwAtg">my_list</span><span class="p" id="mwAtk">.</span><span class="n" id="mwAto">do_all</span><span class="w" id="mwAts"> </span><span class="p" id="mwAtw">(</span><span class="kr" id="mwAt0">agent</span><span class="w" id="mwAt4"> </span><span class="n" id="mwAt8">my_action</span><span class="p" id="mwAuA">)</span>

To execute my_action only on elements satisfying my_condition, a limitation/filter can be added:

<span id="mwAuY"></span><span class="w" id="mwAuc"> </span><span class="n" id="mwAug">my_list</span><span class="p" id="mwAuk">.</span><span class="n" id="mwAuo">do_if</span><span class="w" id="mwAus"> </span><span class="p" id="mwAuw">(</span><span class="kr" id="mwAu0">agent</span><span class="w" id="mwAu4"> </span><span class="n" id="mwAu8">my_action</span><span class="p" id="mwAvA">,</span><span class="w" id="mwAvE"> </span><span class="kr" id="mwAvI">agent</span><span class="w" id="mwAvM"> </span><span class="n" id="mwAvQ">my_condition</span><span class="p" id="mwAvU">)</span>

In these examples, my_action and my_condition are routines. Prefixing them with agent yields an object that represents the corresponding routine with all its properties, in particular the ability to be called with the appropriate arguments. So if a represents that object (for example because a is the argument to do_all), the instruction

<span id="mwAv8"></span><span class="w" id="mwAwA"> </span><span class="n" id="mwAwE">a</span><span class="p" id="mwAwI">.</span><span class="n" id="mwAwM">call</span><span class="w" id="mwAwQ"> </span><span class="p" id="mwAwU">(</span><span class="o" id="mwAwY">[</span><span class="n" id="mwAwc">x</span><span class="o" id="mwAwg">]</span><span class="p" id="mwAwk">)</span>

will call the original routine with the argument x, as if we had directly called the original routine: my_action (x). Arguments to call are passed as a tuple, here [x].

It is possible to keep some arguments to an agent open and make others closed. The open arguments are passed as arguments to call: they are provided at the time of agent use. The closed arguments are provided at the time of agent definition. For example, if action2 has two arguments, the iteration

<span id="mwAxg"></span><span class="w" id="mwAxk"> </span><span class="n" id="mwAxo">my_list</span><span class="p" id="mwAxs">.</span><span class="n" id="mwAxw">do_all</span><span class="w" id="mwAx0"> </span><span class="p" id="mwAx4">(</span><span class="kr" id="mwAx8">agent</span><span class="w" id="mwAyA"> </span><span class="n" id="mwAyE">action2</span><span class="w" id="mwAyI"> </span><span class="p" id="mwAyM">(</span><span class="o" id="mwAyQ">?</span><span class="p" id="mwAyU">,</span><span class="w" id="mwAyY"> </span><span class="n" id="mwAyc">y</span><span class="p" id="mwAyg">))</span>

iterates action2 (x, y) for successive values of x, where the second argument remains set to y. The question mark ? indicates an open argument; y is a closed argument of the agent. Note that the basic syntax agent f is a shorthand for agent f (?, ?, ...) with all arguments open. It is also possible to make the target of an agent open through the notation {T}? where T is the type of the target.

The distinction between open and closed operands (operands = arguments + target) corresponds to the distinction between bound and free variables in lambda calculus. An agent expression such as action2 (?, y) with some operands closed and some open corresponds to a version of the original operation curried on the closed operands.

The agent mechanism also allows defining an agent without reference to an existing routine (such as my_action, my_condition, action2), through inline agents as in

<span id="mwA0A"></span><span class="n" id="mwA0E">my_list</span><span class="p" id="mwA0I">.</span><span class="n" id="mwA0M">do_all</span><span class="w" id="mwA0Q"> </span><span class="p" id="mwA0U">(</span><span class="kr" id="mwA0Y">agent</span><span class="w" id="mwA0c"> </span><span class="p" id="mwA0g">(</span><span class="n" id="mwA0k">s</span><span class="p" id="mwA0o">:</span><span class="w" id="mwA0s"> </span><span class="nc" id="mwA0w">STRING</span><span class="p" id="mwA00">)</span> <span class="w" id="mwA04"> </span><span class="kr" id="mwA08">require</span> <span class="w" id="mwA1A"> </span><span class="n" id="mwA1E">not_void</span><span class="p" id="mwA1I">:</span><span class="w" id="mwA1M"> </span><span class="n" id="mwA1Q">s</span><span class="w" id="mwA1U"> </span><span class="o" id="mwA1Y">/=</span><span class="w" id="mwA1c"> </span><span class="kc" id="mwA1g">Void</span> <span class="w" id="mwA1k"> </span><span class="kr" id="mwA1o">do</span> <span class="w" id="mwA1s"> </span><span class="n" id="mwA1w">s</span><span class="p" id="mwA10">.</span><span class="n" id="mwA14">append_character</span><span class="w" id="mwA18"> </span><span class="p" id="mwA2A">(</span><span class="sc" id="mwA2E">','</span><span class="p" id="mwA2I">)</span> <span class="w" id="mwA2M"> </span><span class="kr" id="mwA2Q">ensure</span> <span class="w" id="mwA2U"> </span><span class="n" id="mwA2Y">appended</span><span class="p" id="mwA2c">:</span><span class="w" id="mwA2g"> </span><span class="n" id="mwA2k">s</span><span class="p" id="mwA2o">.</span><span class="n" id="mwA2s">count</span><span class="w" id="mwA2w"> </span><span class="o" id="mwA20">=</span><span class="w" id="mwA24"> </span><span class="kr" id="mwA28">old</span><span class="w" id="mwA3A"> </span><span class="n" id="mwA3E">s</span><span class="p" id="mwA3I">.</span><span class="n" id="mwA3M">count</span><span class="w" id="mwA3Q"> </span><span class="o" id="mwA3U">+</span><span class="w" id="mwA3Y"> </span><span class="mi" id="mwA3c">1</span> <span class="w" id="mwA3g"> </span><span class="kr" id="mwA3k">end</span><span class="p" id="mwA3o">)</span>

The inline agent passed here can have all the trappings of a normal routine, including precondition, postcondition, rescue clause (not used here), and a full signature. This avoids defining routines when all that's needed is a computation to be wrapped in an agent. This is useful in particular for contracts, as in an invariant clause that expresses that all elements of a list are positive:

<span id="mwA34"></span><span class="w" id="mwA38"> </span><span class="n" id="mwA4A">my_list</span><span class="p" id="mwA4E">.</span><span class="n" id="mwA4I">for_all</span><span class="w" id="mwA4M"> </span><span class="p" id="mwA4Q">(</span><span class="kr" id="mwA4U">agent</span><span class="w" id="mwA4Y"> </span><span class="p" id="mwA4c">(</span><span class="n" id="mwA4g">x</span><span class="p" id="mwA4k">:</span><span class="w" id="mwA4o"> </span><span class="nc" id="mwA4s">INTEGER</span><span class="p" id="mwA4w">):</span><span class="w" id="mwA40"> </span><span class="nc" id="mwA44">BOOLEAN</span><span class="w" id="mwA48"> </span><span class="kr" id="mwA5A">do</span><span class="w" id="mwA5E"> </span><span class="kc" id="mwA5I">Result</span><span class="w" id="mwA5M"> </span><span class="o" id="mwA5Q">:=</span><span class="w" id="mwA5U"> </span><span class="p" id="mwA5Y">(</span><span class="n" id="mwA5c">x</span><span class="w" id="mwA5g"> </span><span class="o" id="mwA5k">></span><span class="w" id="mwA5o"> </span><span class="mi" id="mwA5s">0</span><span class="p" id="mwA5w">)</span><span class="w" id="mwA50"> </span><span class="kr" id="mwA54">end</span><span class="p" id="mwA58">)</span>

The current agent mechanism leaves a possibility of run-time type error (if a routine with n arguments is passed to an agent expecting m arguments with m < n). This can be avoided by a run-time check through the precondition valid_arguments of call. Several proposals for a purely static correction of this problem are available, including a language change proposal by Ribet et al.

Once routines

A routine's result can be cached using the once keyword in place of do. Non-first calls to a routine require no additional computation or resource allocation, but simply return a previously computed result. A common pattern for "once functions" is to provide shared objects; the first call will create the object, subsequent ones will return the reference to that object. The typical scheme is:

<span id="mwA7E"></span><span class="n" id="mwA7I">shared_object</span><span class="p" id="mwA7M">:</span><span class="w" id="mwA7Q"> </span><span class="nc" id="mwA7U">SOME_TYPE</span> <span class="w" id="mwA7Y"> </span><span class="kr" id="mwA7c">once</span> <span class="w" id="mwA7g"> </span><span class="kr" id="mwA7k">create</span><span class="w" id="mwA7o"> </span><span class="kc" id="mwA7s">Result</span><span class="p" id="mwA7w">.</span><span class="n" id="mwA70">make</span><span class="w" id="mwA74"> </span><span class="p" id="mwA78">(</span><span class="n" id="mwA8A">args</span><span class="p" id="mwA8E">)</span> <span class="w" id="mwA8I"> </span><span class="c1" id="mwA8M">-- This creates the object and returns a reference to it through `Result'.</span> <span class="w" id="mwA8Q"> </span><span class="kr" id="mwA8U">end</span>

The returned object—Result in the example—can itself be mutable, but its reference remains the same.

Often "once routines" perform a required initialization: multiple calls to a library can include a call to the initialization procedure, but only the first such call will perform the required actions. Using this pattern initialization can be decentralized, avoiding the need for a special initialization module. "Once routines" are similar in purpose and effect to the singleton pattern in many programming languages, and to the Borg pattern used in Python.

By default, a "once routine" is called once per thread. The semantics can be adjusted to once per process or once per object by qualifying it with a "once key", e.g. once ("PROCESS").

Conversions

Eiffel provides a mechanism to allow conversions between various types. The mechanisms coexists with inheritance and complements it. To avoid any confusion between the two mechanisms, the design enforces the following principle:

(Conversion principle) A type may not both conform and convert to another.

For example, NEWSPAPER may conform to PUBLICATION, but INTEGER converts to REAL (and does not inherit from it).

The conversion mechanism simply generalizes the ad hoc conversion rules (such as indeed between INTEGER and REAL) that exist in most programming languages, making them applicable to any type as long as the above principle is observed. For example, a DATE class may be declared to convert to STRING; this makes it possible to create a string from a date simply through

<span id="mwA-E"></span><span class="w" id="mwA-I"> </span><span class="n" id="mwA-M">my_string</span><span class="w" id="mwA-Q"> </span><span class="o" id="mwA-U">:=</span><span class="w" id="mwA-Y"> </span><span class="n" id="mwA-c">my_date</span>

as a shortcut for using an explicit object creation with a conversion procedure:

<span id="mwA-s"></span><span class="w" id="mwA-w"> </span><span class="kr" id="mwA-0">create</span><span class="w" id="mwA-4"> </span><span class="n" id="mwA-8">my_string</span><span class="p" id="mwA_A">.</span><span class="n" id="mwA_E">make_from_date</span><span class="w" id="mwA_I"> </span><span class="p" id="mwA_M">(</span><span class="n" id="mwA_Q">my_date</span><span class="p" id="mwA_U">)</span>

To make the first form possible as a synonym for the second, it suffices to list the creation procedure (constructor) make_from_date in a convert clause at the beginning of the class.

As another example, if there is such a conversion procedure listed from TUPLE [day: INTEGER; month: STRING; year: INTEGER], then one can directly assign a tuple to a date, causing the appropriate conversion, as in

<span id="mwA_0"></span><span class="w" id="mwA_4"> </span><span class="n" id="mwA_8">Bastille_day</span><span class="w" id="mwBAA"> </span><span class="o" id="mwBAE">:=</span><span class="w" id="mwBAI"> </span><span class="o" id="mwBAM">[</span><span class="mi" id="mwBAQ">14</span><span class="p" id="mwBAU">,</span><span class="w" id="mwBAY"> </span><span class="s" id="mwBAc">"July"</span><span class="p" id="mwBAg">,</span><span class="w" id="mwBAk"> </span><span class="mi" id="mwBAo">1789</span><span class="o" id="mwBAs">]</span>

Exception handling

Exception handling in Eiffel is based on the principles of design by contract. For example, an exception occurs when a routine's caller fails to satisfy a precondition, or when a routine cannot ensure a promised postcondition. In Eiffel, exception handling is not used for control flow or to correct data-input mistakes.

An Eiffel exception handler is defined using the rescue keyword. Within the rescue section, the retry keyword executes the routine again. For example, the following routine tracks the number of attempts at executing the routine, and only retries a certain number of times:

<span id="mwBBk"></span><span class="n" id="mwBBo">connect_to_server</span><span class="w" id="mwBBs"> </span><span class="p" id="mwBBw">(</span><span class="n" id="mwBB0">server</span><span class="p" id="mwBB4">:</span><span class="w" id="mwBB8"> </span><span class="nc" id="mwBCA">SOCKET</span><span class="p" id="mwBCE">)</span> <span class="w" id="mwBCI"> </span><span class="c1" id="mwBCM">-- Connect to a server or give up after 10 attempts.</span> <span class="w" id="mwBCQ"> </span><span class="kr" id="mwBCU">require</span> <span class="w" id="mwBCY"> </span><span class="n" id="mwBCc">server</span><span class="w" id="mwBCg"> </span><span class="o" id="mwBCk">/=</span><span class="w" id="mwBCo"> </span><span class="kc" id="mwBCs">Void</span><span class="w" id="mwBCw"> </span><span class="ow" id="mwBC0">and</span><span class="w" id="mwBC4"> </span><span class="ow" id="mwBC8">then</span><span class="w" id="mwBDA"> </span><span class="n" id="mwBDE">server</span><span class="p" id="mwBDI">.</span><span class="n" id="mwBDM">address</span><span class="w" id="mwBDQ"> </span><span class="o" id="mwBDU">/=</span><span class="w" id="mwBDY"> </span><span class="kc" id="mwBDc">Void</span> <span class="w" id="mwBDg"> </span><span class="kr" id="mwBDk">local</span> <span class="w" id="mwBDo"> </span><span class="n" id="mwBDs">attempts</span><span class="p" id="mwBDw">:</span><span class="w" id="mwBD0"> </span><span class="nc" id="mwBD4">INTEGER</span> <span class="w" id="mwBD8"> </span><span class="kr" id="mwBEA">do</span> <span class="w" id="mwBEE"> </span><span class="n" id="mwBEI">server</span><span class="p" id="mwBEM">.</span><span class="n" id="mwBEQ">connect</span> <span class="w" id="mwBEU"> </span><span class="kr" id="mwBEY">ensure</span> <span class="w" id="mwBEc"> </span><span class="n" id="mwBEg">connected</span><span class="p" id="mwBEk">:</span><span class="w" id="mwBEo"> </span><span class="n" id="mwBEs">server</span><span class="p" id="mwBEw">.</span><span class="n" id="mwBE0">is_connected</span> <span class="w" id="mwBE4"> </span><span class="kr" id="mwBE8">rescue</span> <span class="w" id="mwBFA"> </span><span class="kr" id="mwBFE">if</span><span class="w" id="mwBFI"> </span><span class="n" id="mwBFM">attempts</span><span class="w" id="mwBFQ"> </span><span class="o" id="mwBFU"><</span><span class="w" id="mwBFY"> </span><span class="mi" id="mwBFc">10</span><span class="w" id="mwBFg"> </span><span class="kr" id="mwBFk">then</span> <span class="w" id="mwBFo"> </span><span class="n" id="mwBFs">attempts</span><span class="w" id="mwBFw"> </span><span class="o" id="mwBF0">:=</span><span class="w" id="mwBF4"> </span><span class="n" id="mwBF8">attempts</span><span class="w" id="mwBGA"> </span><span class="o" id="mwBGE">+</span><span class="w" id="mwBGI"> </span><span class="mi" id="mwBGM">1</span> <span class="w" id="mwBGQ"> </span><span class="kr" id="mwBGU">retry</span> <span class="w" id="mwBGY"> </span><span class="kr" id="mwBGc">end</span> <span class="w" id="mwBGg"> </span><span class="kr" id="mwBGk">end</span>

This example is arguably flawed for anything but the simplest programs, however, because connection failure is to be expected. For most programs a routine name like attempt_connecting_to_server would be better, and the postcondition would not promise a connection, leaving it up to the caller to take appropriate steps if the connection was not opened.

Concurrency

A number of networking and threading libraries are available, such as EiffelNet and EiffelThreads. A concurrency model for Eiffel, based on the concepts of design by contract, is SCOOP, or Simple Concurrent Object-Oriented Programming, not yet part of the official language definition but available in EiffelStudio. CAMEO is an (unimplemented) variation of SCOOP for Eiffel. Concurrency also interacts with exceptions. Asynchronous exceptions can be troublesome (where a routine raises an exception after its caller has itself finished).

Operator and bracket syntax, assigner commands

Eiffel's view of computation is completely object-oriented in the sense that every operation is relative to an object, the "target". So for example an addition such as

<span id="mwBH4"></span><span class="n" id="mwBH8">a</span><span class="w" id="mwBIA"> </span><span class="o" id="mwBIE">+</span><span class="w" id="mwBII"> </span><span class="n" id="mwBIM">b</span>

is conceptually understood as if it were the method call

<span id="mwBIc"></span><span class="n" id="mwBIg">a</span><span class="p" id="mwBIk">.</span><span class="n" id="mwBIo">plus</span><span class="w" id="mwBIs"> </span><span class="p" id="mwBIw">(</span><span class="n" id="mwBI0">b</span><span class="p" id="mwBI4">)</span>

with target a, feature plus and argument b.

Of course, the former is the conventional syntax and usually preferred. Operator syntax makes it possible to use either form by declaring the feature (for example in INTEGER, but this applies to other basic classes and can be used in any other for which such an operator is appropriate):

<span id="mwBJc"></span><span id="plus-1"><a href="#plus-1" id="mwBJg"><span class="linenos" data-line="1" id="mwBJk"></span></a><span class="n" id="mwBJo">plus</span><span class="w" id="mwBJs"> </span><span class="kr" id="mwBJw">alias</span><span class="w" id="mwBJ0"> </span><span class="s" id="mwBJ4">"+"</span><span class="w" id="mwBJ8"> </span><span class="p" id="mwBKA">(</span><span class="n" id="mwBKE">other</span><span class="p" id="mwBKI">:</span><span class="w" id="mwBKM"> </span><span class="nc" id="mwBKQ">INTEGER</span><span class="p" id="mwBKU">):</span><span class="w" id="mwBKY"> </span><span class="nc" id="mwBKc">INTEGER</span> </span><span id="plus-2"><a href="#plus-2" id="mwBKg"><span class="linenos" data-line="2" id="mwBKk"></span></a><span class="w" id="mwBKo"> </span><span class="c1" id="mwBKs">-- ... Normal function declaration...</span> </span><span id="plus-3"><a href="#plus-3" id="mwBKw"><span class="linenos" data-line="3" id="mwBK0"></span></a><span class="w" id="mwBK4"> </span><span class="kr" id="mwBK8">end</span> </span>

The range of operators that can be used as "alias" is quite broad; they include predefined operators such as "+" but also "free operators" made of non-alphanumeric symbols. This makes it possible to design special infix and prefix notations, for example in mathematics and physics applications.

Every class may in addition have one function aliased to "[]", the "bracket" operator, allowing the notation a [i, ...] as a synonym for a.f (i, ...) where f is the chosen function. This is particularly useful for container structures such as arrays, hash tables, lists etc. For example, access to an element of a hash table with string keys can be written

<span id="mwBLk"></span><span class="w" id="mwBLo"> </span><span class="n" id="mwBLs">number</span><span class="w" id="mwBLw"> </span><span class="o" id="mwBL0">:=</span><span class="w" id="mwBL4"> </span><span class="n" id="mwBL8">phone_book</span><span class="w" id="mwBMA"> </span><span class="o" id="mwBME">[</span><span class="s" id="mwBMI">"JILL SMITH"</span><span class="o" id="mwBMM">]</span>

"Assigner commands" are a companion mechanism designed in the same spirit of allowing well-established, convenient notation reinterpreted in the framework of object-oriented programming. Assigner commands allow assignment-like syntax to call "setter" procedures. An assignment proper can never be of the form a.x := v as this violates information hiding; you have to go for a setter command (procedure). For example, the hash table class can have the function and the procedure

<span id="mwBMk"></span><span id="assigner-command-1"><a href="#assigner-command-1" id="mwBMo"><span class="linenos" data-line="1" id="mwBMs"></span></a><span class="c1" id="mwBMw">-- Aliases and assigner commands</span> </span><span id="assigner-command-2"><a href="#assigner-command-2" id="mwBM0"><span class="linenos" data-line="2" id="mwBM4"></span></a> </span><span id="assigner-command-3"><a href="#assigner-command-3" id="mwBM8"><span class="linenos" data-line="3" id="mwBNA"></span></a><span class="n" id="mwBNE">item</span><span class="w" id="mwBNI"> </span><span class="kr" id="mwBNM">alias</span><span class="w" id="mwBNQ"> </span><span class="s" id="mwBNU">"[]"</span><span class="w" id="mwBNY"> </span><span class="p" id="mwBNc">(</span><span class="n" id="mwBNg">key</span><span class="p" id="mwBNk">:</span><span class="w" id="mwBNo"> </span><span class="nc" id="mwBNs">STRING</span><span class="p" id="mwBNw">):</span><span class="w" id="mwBN0"> </span><span class="nc" id="mwBN4">ELEMENT</span><span class="w" id="mwBN8"> </span><span class="c1" id="mwBOA">-- ☝︎1</span> </span><span id="assigner-command-4"><a href="#assigner-command-4" id="mwBOE"><span class="linenos" data-line="4" id="mwBOI"></span></a><span class="w" id="mwBOM"> </span><span class="c1" id="mwBOQ">-- The element of key `key'.</span> </span><span id="assigner-command-5"><a href="#assigner-command-5" id="mwBOU"><span class="linenos" data-line="5" id="mwBOY"></span></a><span class="w" id="mwBOc"> </span><span class="c1" id="mwBOg">-- ("Getter" query)</span> </span><span id="assigner-command-6"><a href="#assigner-command-6" id="mwBOk"><span class="linenos" data-line="6" id="mwBOo"></span></a><span class="w" id="mwBOs"> </span><span class="kr" id="mwBOw">do</span> </span><span id="assigner-command-7"><a href="#assigner-command-7" id="mwBO0"><span class="linenos" data-line="7" id="mwBO4"></span></a><span class="w" id="mwBO8"> </span><span class="p" id="mwBPA">...</span> </span><span id="assigner-command-8"><a href="#assigner-command-8" id="mwBPE"><span class="linenos" data-line="8" id="mwBPI"></span></a><span class="w" id="mwBPM"> </span><span class="kr" id="mwBPQ">end</span> </span><span id="assigner-command-9"><a href="#assigner-command-9" id="mwBPU"><span class="linenos" data-line="9" id="mwBPY"></span></a> </span><span id="assigner-command-10"><a href="#assigner-command-10" id="mwBPc"><span class="linenos" data-line="10" id="mwBPg"></span></a><span class="n" id="mwBPk">put</span><span class="w" id="mwBPo"> </span><span class="p" id="mwBPs">(</span><span class="n" id="mwBPw">e</span><span class="p" id="mwBP0">:</span><span class="w" id="mwBP4"> </span><span class="nc" id="mwBP8">ELEMENT</span><span class="p" id="mwBQA">;</span><span class="w" id="mwBQE"> </span><span class="n" id="mwBQI">key</span><span class="p" id="mwBQM">:</span><span class="w" id="mwBQQ"> </span><span class="nc" id="mwBQU">STRING</span><span class="p" id="mwBQY">)</span> </span><span id="assigner-command-11"><a href="#assigner-command-11" id="mwBQc"><span class="linenos" data-line="11" id="mwBQg"></span></a><span class="w" id="mwBQk"> </span><span class="c1" id="mwBQo">-- Insert the element `e', associating it with the key `key'.</span> </span><span id="assigner-command-12"><a href="#assigner-command-12" id="mwBQs"><span class="linenos" data-line="12" id="mwBQw"></span></a><span class="w" id="mwBQ0"> </span><span class="c1" id="mwBQ4">-- ("Setter" command)</span> </span><span id="assigner-command-13"><a href="#assigner-command-13" id="mwBQ8"><span class="linenos" data-line="13" id="mwBRA"></span></a><span class="w" id="mwBRE"> </span><span class="kr" id="mwBRI">do</span> </span><span id="assigner-command-14"><a href="#assigner-command-14" id="mwBRM"><span class="linenos" data-line="14" id="mwBRQ"></span></a><span class="w" id="mwBRU"> </span><span class="p" id="mwBRY">...</span> </span><span id="assigner-command-15"><a href="#assigner-command-15" id="mwBRc"><span class="linenos" data-line="15" id="mwBRg"></span></a><span class="w" id="mwBRk"> </span><span class="kr" id="mwBRo">end</span> </span>

Then to insert an element you have to use an explicit call to the setter command:

<span id="mwBR4"></span><span id="using-put-1"><span class="w" id="mwBR8"> </span><span class="c1" id="mwBSA">-- using put() directly</span> </span><span id="using-put-2"><span class="w" id="mwBSE"> </span><span class="n" id="mwBSI">phone_book</span><span class="p" id="mwBSM">.</span><span class="n" id="mwBSQ">put</span><span class="w" id="mwBSU"> </span><span class="p" id="mwBSY">(</span><span class="n" id="mwBSc">New_person</span><span class="p" id="mwBSg">,</span><span class="w" id="mwBSk"> </span><span class="s" id="mwBSo">"JILL SMITH"</span><span class="p" id="mwBSs">)</span><span class="w" id="mwBSw"> </span><span class="c1" id="mwBS0">-- ☝︎2</span> </span>

It is possible to write this equivalently as

<span id="mwBTE"></span><span id="using-alias-1"><span class="w" id="mwBTI"> </span><span class="c1" id="mwBTM">-- using alias</span> </span><span id="using-alias-2"><span class="w" id="mwBTQ"> </span><span class="n" id="mwBTU">phone_book</span><span class="w" id="mwBTY"> </span><span class="o" id="mwBTc">[</span><span class="s" id="mwBTg">"JILL SMITH"</span><span class="o" id="mwBTk">]</span><span class="w" id="mwBTo"> </span><span class="o" id="mwBTs">:=</span><span class="w" id="mwBTw"> </span><span class="n" id="mwBT0">New_person</span><span class="w" id="mwBT4"> </span><span class="c1" id="mwBT8">-- ☝︎3</span> </span>

(in the same way that phone_book ["JILL SMITH"] is a synonym for number := phone_book.item ("JILL SMITH")), provided the declaration of item now starts (replacement for ☝︎₁) with

<span id="mwBUk"></span><span class="w" id="mwBUo"> </span><span class="n" id="mwBUs">item</span><span class="w" id="mwBUw"> </span><span class="kr" id="mwBU0">alias</span><span class="w" id="mwBU4"> </span><span class="s" id="mwBU8">"[]"</span><span class="w" id="mwBVA"> </span><span class="p" id="mwBVE">(</span><span class="n" id="mwBVI">key</span><span class="p" id="mwBVM">:</span><span class="w" id="mwBVQ"> </span><span class="nc" id="mwBVU">STRING</span><span class="p" id="mwBVY">):</span><span class="w" id="mwBVc"> </span><span class="nc" id="mwBVg">ELEMENT</span><span class="w" id="mwBVk"> </span><span class="kr" id="mwBVo">assign</span><span class="w" id="mwBVs"> </span><span class="n" id="mwBVw">put</span>

This declares put as the assigner command associated with item and, combined with the bracket alias, makes ☝︎₃ legal and equivalent to ☝︎₂. (It could also be written, without taking advantage of the bracket, as phone_book.item ("JILL SMITH") := New_person.

Note: The argument list of a's assigner is constrained to be: (a's return type; all of a's argument list...)

Lexical and syntax properties

Eiffel is not case-sensitive. The tokens make, maKe and MAKE all denote the same identifier. See, however, the "style rules" below.

Comments are introduced by -- (two consecutive dashes) and extend to the end of the line.

The semicolon, as instruction separator, is optional. Most of the time the semicolon is just omitted, except to separate multiple instructions on a line. This results in less clutter on the program page.

There is no nesting of feature and class declarations. As a result, the structure of an Eiffel class is simple: some class-level clauses (inheritance, invariant) and a succession of feature declarations, all at the same level.

It is customary to group features into separate "feature clauses" for more readability, with a standard set of basic feature tags appearing in a standard order, for example:

<span id="mwBXQ"></span><span class="kr" id="mwBXU">class</span><span class="w" id="mwBXY"> </span><span class="nc" id="mwBXc">HASH_TABLE</span><span class="w" id="mwBXg"> </span><span class="o" id="mwBXk">[</span><span class="nc" id="mwBXo">ELEMENT</span><span class="p" id="mwBXs">,</span><span class="w" id="mwBXw"> </span><span class="nc" id="mwBX0">KEY</span><span class="w" id="mwBX4"> </span><span class="o" id="mwBX8">-></span><span class="w" id="mwBYA"> </span><span class="nc" id="mwBYE">HASHABLE</span><span class="o" id="mwBYI">]</span><span class="w" id="mwBYM"> </span><span class="kr" id="mwBYQ">inherit</span><span class="w" id="mwBYU"> </span><span class="nc" id="mwBYY">TABLE</span><span class="w" id="mwBYc"> </span><span class="o" id="mwBYg">[</span><span class="nc" id="mwBYk">ELEMENT</span><span class="o" id="mwBYo">]</span> <span class="w" id="mwBYs"> </span><span class="kr" id="mwBYw">feature</span><span class="w" id="mwBY0"> </span><span class="c1" id="mwBY4">-- Initialization</span> <span class="w" id="mwBY8"> </span><span class="c1" id="mwBZA">-- ... Declarations of initialization commands (creation procedures/constructors) ...</span> <span class="w" id="mwBZE"> </span><span class="kr" id="mwBZI">feature</span><span class="w" id="mwBZM"> </span><span class="c1" id="mwBZQ">-- Access</span> <span class="w" id="mwBZU"> </span><span class="c1" id="mwBZY">-- ... Declarations of non-Boolean queries on the object state, e.g. item ...</span> <span class="w" id="mwBZc"> </span><span class="kr" id="mwBZg">feature</span><span class="w" id="mwBZk"> </span><span class="c1" id="mwBZo">-- Status report</span> <span class="w" id="mwBZs"> </span><span class="c1" id="mwBZw">-- ... Declarations of Boolean queries on the object state, e.g. is_empty ...</span> <span class="w" id="mwBZ0"> </span><span class="kr" id="mwBZ4">feature</span><span class="w" id="mwBZ8"> </span><span class="c1" id="mwBaA">-- Element change</span> <span class="w" id="mwBaE"> </span><span class="c1" id="mwBaI">-- ... Declarations of commands that change the structure, e.g. put ...</span> <span class="w" id="mwBaM"> </span><span class="c1" id="mwBaQ">-- etc.</span> <span class="kr" id="mwBaU">end</span>

In contrast to most curly bracket programming languages, Eiffel makes a clear distinction between expressions and instructions. This is in line with the Command-Query Separation principle of the Eiffel method.

Style conventions

Much of the documentation of Eiffel uses distinctive style conventions, designed to enforce a consistent look-and-feel. Some of these conventions apply to the code format itself, and others to the standard typographic rendering of Eiffel code in formats and publications where these conventions are possible.

While the language is case-insensitive, the style standards prescribe the use of all-capitals for class names (LIST), all-lower-case for feature names (make), and initial capitals for constants (Avogadro). The recommended style also suggests underscore to separate components of a multi-word identifier, as in average_temperature.

The specification of Eiffel includes guidelines for displaying software texts in typeset formats: keywords in bold, user-defined identifiers and constants are shown in italics, comments, operators, and punctuation marks in Roman, with program text in blue as in the present article to distinguish it from explanatory text. For example, the "Hello, world!" program given above would be rendered as below in Eiffel documentation:

<b id="mwBbs">class</b> <i id="mwBbw">HELLO_WORLD</i> <b id="mwBb0">create</b> <i id="mwBb4">make</i> <b id="mwBb8">feature</b> <i id="mwBcA">make</i> <b id="mwBcE">do</b> print ("<a rel="mw:WikiLink" href="./Hello,_world!" title="Hello, world!" class="mw-redirect" id="mwBcI">Hello, world!</a>") <b id="mwBcM">end</b> <b id="mwBcQ">end</b>

Interfaces to other tools and languages

Eiffel is a purely object-oriented language but provides an open architecture for interfacing with "external" software in any other programming language.

It is possible for example to program machine- and operating-system level operations in C. Eiffel provides a straightforward interface to C routines, including support for "inline C" (writing the body of an Eiffel routine in C, typically for short machine-level operations).

There is no direct connection between Eiffel and C. However, many Eiffel compilers (Visual Eiffel is one exception) emit C source code as an intermediate language, to submit to a C compiler, for optimizing or porting. As such, they are examples of transcompilers. The Eiffel Compiler tecomp can execute Eiffel code directly (like an interpreter) without going via an intermediate C code or emit C code which will be passed to a C compiler to obtain optimized native code. On .NET, the EiffelStudio compiler directly generates Common Intermediate Language (CIL) code. The SmartEiffel compiler can also emit Java bytecode.