Eiffel (язык программирования) - Википедия - Eiffel (programming language)

Эта статья нужны дополнительные цитаты для проверка. Пожалуйста помоги улучшить эту статью к добавление цитат в надежные источники. Материал, не полученный от источника, может быть оспорен и удален Найдите источники: Язык программирования "Эйфель"  – Новости  · газеты  · книги  · ученый  · JSTOR (Январь 2015) (Узнайте, как и когда удалить этот шаблон сообщения)

Эйфель

Парадигма	Объектно-ориентированный, На основе классов, Универсальный, Одновременный
Разработано	Бертран Мейер
Разработчик	Eiffel Software
Впервые появился	1986[1]
Стабильный выпуск	EiffelStudio 19.05[2] / 22 мая 2019; 18 месяцев назад (2019-05-22)
Предварительный выпуск	EiffelStudio 20.05[3] / 17 июня 2020; 5 месяцев назад (2020-06-17)
Печатная дисциплина	статический
Язык реализации	Эйфель
Платформа	Кроссплатформенность
Операционные системы	FreeBSD, Linux, Mac OS X, OpenBSD, Солярис, Windows
Лицензия	двойной и корпоративный
Расширения имени файла	.e
Интернет сайт	www.eiffel.org
Основной реализации
EiffelStudio, СвободаЭйфелева, SmartEiffel, Визуальный Эйфель, Гобо Эйфель, "Компилятор Эйфеля" tecomp
Под влиянием
Ада, Симула, Z
Под влиянием
Ада 2012, Альбатрос, C #, D, Ява, Ракетка, Рубин,[4] Sather, Scala

Эйфель является объектно-ориентированный язык программирования разработано Бертран Мейер (сторонник объектной ориентации и автор Построение объектно-ориентированного программного обеспечения ) и Eiffel Software. Мейер придумал язык в 1985 году с целью повышения надежности разработки коммерческого программного обеспечения;^[5] первая версия стала доступна в 1986 году. В 2005 году Eiffel стал ISO -стандартный язык.

Дизайн языка тесно связан с методом программирования Эйфеля. Оба основаны на наборе принципов, в том числе дизайн по контракту, разделение команд и запросов, то принцип единого доступа, то принцип единственного выбора, то открытый – закрытый принцип, и опция – разделение операндов.

Многие концепции, первоначально введенные Эйфелем, позже нашли свое отражение в Ява, C #, и другие языки.^[6] Новые идеи языкового дизайна, особенно через Экма /ISO процесс стандартизации, продолжает включаться в язык Eiffel.

Характеристики

Ключевые характеристики языка Eiffel включают:

• Объектно-ориентированная программная структура, в которой класс служит базовой единицей декомпозиции.
• Дизайн по контракту тесно интегрирован с другими языковыми конструкциями.
• Автоматическое управление памятью, обычно реализуемое вывоз мусора.
• Наследование, включая множественное наследование, переименование, переопределение, "Выбрать", несоответствующее наследование, и другие механизмы, предназначенные для обеспечения безопасности наследования.
• Сдержанный и неограниченный общее программирование
• Униформа система типов обработка семантики значений и ссылок, в которой все типы, включая базовые типы, такие как INTEGER, основаны на классах.
• Статическая типизация
• Безопасность пустоты или статическая защита от обращений к нулевым ссылкам через механизм прикрепленных типов.
• Агенты или объекты, которые обертывают вычисления, тесно связанные с закрытие и лямбда-исчисление.
• Один раз процедуры или процедуры, оцениваемые только один раз, для совместного использования объектов и децентрализованной инициализации.
• Синтаксис на основе ключевых слов в АЛГОЛ /Паскаль по традиции, но без разделителей, поскольку точки с запятой не обязательны, а синтаксис операторов доступен для подпрограмм.
• Нечувствительность к регистру
• Простое параллельное объектно-ориентированное программирование (SCOOP ) облегчает создание нескольких, одновременно активных средств выполнения на уровне абстракции, превышающем конкретные детали этих средств (например, несколько потоков без специального управления мьютексами).

Цели дизайна

Эйфель делает упор на декларативные заявления, а не на процедурный код, и пытается устранить необходимость в инструкциях по ведению бухгалтерского учета.

Эйфель избегает уловок кодирования или техник кодирования, предназначенных для оптимизация подсказки компилятору. Цель состоит не только в том, чтобы сделать код более читаемым, но и в том, чтобы позволить программистам сконцентрироваться на важных аспектах программы, не увязая в деталях реализации. Простота Eiffel предназначена для обеспечения простых, расширяемых, многоразовых и надежных ответов на вычислительные проблемы. Компиляторы для компьютерных программ, написанных на Eiffel, предоставляют обширные методы оптимизации, такие как автоматическое встраивание, которые освобождают программиста от части бремени оптимизации.

Фон

Eiffel был первоначально разработан Eiffel Software, компанией, основанной Бертран Мейер. Построение объектно-ориентированного программного обеспечения содержит подробное описание концепций и теории объектной технологии, которые привели к созданию Эйфеля.^[7]

Цель разработки, лежащая в основе языка Eiffel, библиотек и методов программирования, - дать программистам возможность создавать надежные, многократно используемые программные модули. Эйфелева поддерживает множественное наследование, универсальность, полиморфизм, инкапсуляция, безопасные преобразования типов и ковариация параметров. Самый важный вклад Эйфеля в программная инженерия является дизайн по контракту (DbC), в котором утверждения, предварительные условия, постусловия, и инварианты классов используются для обеспечения правильности программы без ущерба для эффективности.

Дизайн Эйфеля основан на теории объектно-ориентированного программирования с незначительным влиянием других парадигм или заботой о поддержке устаревшего кода. Эйфель формально поддерживает абстрактные типы данных. По замыслу Эйфеля, программный текст должен иметь возможность воспроизводить свою проектную документацию из самого текста, используя формализованную реализацию «абстрактного типа данных».

Реализации и среды

EiffelStudio является интегрированная среда развития доступны либо под Открытый исходный код или коммерческая лицензия. Он предлагает объектно-ориентированную среду для программная инженерия. EiffelEnvision - это плагин для Microsoft Visual Studio который позволяет пользователям редактировать, компилировать и отлаживать проекты Eiffel из среды Microsoft Visual Studio IDE. Пять других Открытый исходный код доступны реализации: Tecomp "The Eiffel Compiler"; Гобо Эйфель; SmartEiffel, реализация GNU, основанная на более старой версии языка; СвободаЭйфелева, на основе компилятора SmartEiffel; и Визуальный Эйфель.

Некоторые другие языки программирования включают элементы, впервые представленные в Eiffel. Sather, например, изначально был основан на Эйфеле, но с тех пор разошелся и теперь включает несколько функциональное программирование Особенности. Язык интерактивного обучения Blue, предшественник BlueJ, также основан на Эйфеле. В Инструмент Apple Media включает язык Apple Media на основе Eiffel.

Технические характеристики и стандарты

Определение языка Eiffel является международным стандартом ISO. Стандарт разработан ECMA International, которая впервые утвердила стандарт 21 июня 2005 г. как Стандарт ECMA-367, Eiffel: Analysis, Design and Programming Language. В июне 2006 года ECMA и ISO приняли вторую версию. В ноябре 2006 года ISO впервые опубликовала эту версию. Стандарт можно найти и бесплатно использовать на сайте ECMA.^[8] Версия ISO^[9] идентичен во всех отношениях, кроме форматирования.

Eiffel Software, Tecomp "Eiffel Compiler" и разработчик библиотеки Eiffel Gobo взяли на себя обязательство внедрить стандарт; EiffelStudio 6.1 и «Компилятор Eiffel» Tecomp от Eiffel Software реализуют некоторые из основных новых механизмов, в частности, встроенные агенты, команды присваивания, скобочную нотацию, несоответствующее наследование и присоединенные типы. В SmartEiffel Команда отвернулась от этого стандарта, чтобы создать свою собственную версию языка, которая, по их мнению, ближе к исходному стилю Eiffel. Object Tools не раскрывает, будут ли будущие версии его компилятора Eiffel соответствовать стандарту. СвободаЭйфелева реализует диалект где-то между SmartEiffel язык и стандарт.

Стандарт цитирует следующие предшествующие спецификации языка Eiffel:

• Бертран Мейер: Eiffel: The Language, Prentice Hall, вторая печать, 1992 г. (первая печать: 1991 г.)
• Бертран Мейер: Standard Eiffel (пересмотр предыдущей статьи), продолжается, 1997 - настоящее время, на странице Бертрана Мейера в ETL3, и
• Бертран Мейер: Построение объектно-ориентированного программного обеспечения, Prentice Hall: первое издание, 1988; Издание второе, 1997 г.
• Бертран Мейер: Прикосновение к классу: научиться хорошо программировать с помощью объектов и контрактов, Springer-Verlag, 2009 г. ISBN  978-3-540-92144-8 lxiv + 876 стр. Полноцветная печать, множество цветных фотографий

Текущая версия стандарта от июня 2006 г. содержит некоторые несоответствия (например, ковариантные переопределения).^{[нужна цитата ]}. Комитет ECMA еще не объявил никаких сроков и указаний по устранению несоответствий.

Синтаксис и семантика

Общая структура

"Система" или "программа" Эйфеля - это совокупность классы. Выше уровня классов Эйфель определяет кластер, который по сути является группой классов и, возможно, подкластеры (вложенные кластеры). Кластеры - это не синтаксис языковая конструкция, а скорее стандартное организационное соглашение. Обычно программа Eiffel организована с каждым классом в отдельном файле, а каждый кластер - в каталоге, содержащем файлы классов. В этой организации подкластеры - это подкаталоги. Например, в соответствии со стандартными организационными соглашениями и соглашениями о корпусе x.e может быть именем файла, который определяет класс с именем X.

Класс содержит Особенности, которые похожи на «процедуры», «члены», «атрибуты» или «методы» в других объектно-ориентированных языках программирования. Класс также определяет свои инварианты и содержит другие свойства, такие как раздел «примечания» для документации и метаданных. Стандартные типы данных Эйфеля, такие как ЦЕЛОЕ, НИТЬ и МНОЖЕСТВО, все сами классы.

В каждой системе должен быть класс, обозначенный как «root», а одна из процедур его создания - как «корневая процедура». Выполнение системы состоит из создания экземпляра корневого класса и выполнения его корневой процедуры. Как правило, при этом создаются новые объекты, вызываются новые функции и т. Д.

У Eiffel есть пять основных исполняемых инструкций: назначение, создание объекта, вызов подпрограммы, условие и итерация. Управляющие структуры Eiffel строго следят за соблюдением структурного программирования: каждый блок имеет ровно одну запись и ровно один выход.

Определение объема

В отличие от многих объектно-ориентированных языков, но как и Болтовня, Eiffel не допускает никакого присвоения атрибутам объектов, кроме как в пределах характеристик объекта, что является практическим применением принципа скрытие информации или абстракция данных, требующая формальных интерфейсов для мутации данных. Чтобы перевести его на язык других объектно-ориентированных языков программирования, все атрибуты Eiffel являются «защищенными», а для изменения значений клиентскими объектами необходимы «установщики». Результатом этого является то, что «установщики» могут и обычно реализуют инварианты, для которых Eiffel предоставляет синтаксис.

Хотя Eiffel не разрешает прямой доступ к функциям класса клиенту класса, он допускает определение «команды-назначителя», например:

    some_attribute: SOME_TYPE назначать set_some_attribute       set_some_attribute (v: ТИП ЦЕННОСТИ)                - Установить значение some_attribute равным `v '.            делать                some_attribute := v            конец

Несмотря на небольшой поклон всему сообществу разработчиков, чтобы разрешить что-то похожее на прямой доступ (например, тем самым нарушая принцип сокрытия информации), такая практика опасна, поскольку она скрывает или запутывает реальность использования «установщика». На практике лучше перенаправить вызов сеттеру, чем предполагать прямой доступ к такой функции, как some_attribute как в примере кода выше.

В отличие от других языков, имеющих понятия «общедоступный», «защищенный», «частный» и т. Д., Eiffel использует технологию экспорта, чтобы более точно контролировать область видимости между классами клиента и поставщика. Видимость функции проверяется статически во время компиляции. Например, (ниже) "{NONE}" аналогично слову "protected" в других языках. Область применения, примененная таким образом к «набору функций» (например, все, что находится ниже ключевого слова «характеристика» до следующего ключевого слова набора функций или конца класса), может быть изменено в классах-потомках с помощью ключевого слова «экспорт».

особенность {НИКТО} - Инициализация	default_create			- Инициализировать новый "нулевой" десятичный экземпляр.		делать			make_zero		конец

В качестве альтернативы, отсутствие экспортной декларации {x} подразумевает {ЛЮБОЙ} и аналогично "общедоступной" области видимости других языков.

особенность - Константы

Наконец, область видимости можно выборочно и точно контролировать для любого класса во вселенной проекта Eiffel, например:

особенность {ДЕСЯТИЧНЫЙ, DCM_MA_DECIMAL_PARSER, DCM_MA_DECIMAL_HANDLER} -- Доступ

Здесь компилятор разрешит только классам, перечисленным в фигурных скобках, получить доступ к функциям в группе функций (например, DECIMAL, DCM_MA_DECIMAL_PARSER, DCM_MA_DECIMAL_HANDLER).

"Привет, мир!"

Внешний вид языка программирования часто передается с помощью "Привет, мир!" программа. Такая программа, написанная на Eiffel, может быть:

учебный класс    ПРИВЕТ, МИРСоздайте    делатьособенность    делать        делать            Распечатать («Привет, мир!% N»)        конецконец

Эта программа содержит класс ПРИВЕТ, МИР. Конструктор (процедура создания) для класса с именем делать, вызывает Распечатать подпрограмма системной библиотеки для написания "Привет, Мир!" сообщение на выход.

Дизайн по контракту

Концепция дизайна по контракту занимает центральное место в Eiffel. Контракты утверждают, что должно быть истинным до выполнения подпрограммы (предварительное условие) и что должно выполняться, чтобы быть истинным после завершения подпрограммы (постусловие). Контракты инварианта класса определяют, какие утверждения должны выполняться до и после доступа к любой функции класса (как к процедурам, так и к атрибутам). Более того, контракты кодифицируют в исполняемом коде предположения разработчиков и дизайнеров об операционной среде функций класса или класса в целом с помощью инварианта.

Компилятор Eiffel предназначен для включения контрактов функций и классов на различных уровнях. EiffelStudio, например, выполняет все контракты функций и классов во время выполнения в «режиме Workbench». Когда исполняемый файл создается, компилятор получает команду через файл настроек проекта (например, файл ECF), чтобы включить или исключить любой набор контрактов. Таким образом, исполняемый файл может быть скомпилирован для включения или исключения любого уровня контракта, тем самым обеспечивая непрерывные уровни модульного и интеграционного тестирования. Более того, контракты могут выполняться непрерывно и методично с помощью функции автотеста в EiffelStudio.

Механизмы проектирования по контракту тесно интегрированы с языком и руководят переопределением функций в наследовании:

• Обычное предварительное условие: предварительное условие может быть ослаблено только наследованием; любой вызов, отвечающий требованиям предка, соответствует требованиям потомка.
• Обычное постусловие: Постусловие может быть усилено только наследованием; любой результат, гарантированный предком, по-прежнему предоставляется потомком.
• Инвариант класса: условия, которые должны выполняться после создания объекта и после любого вызова экспортированной подпрограммы класса. Поскольку инвариант проверяется так часто, это делает его одновременно и самой дорогой, и самой мощной формой условия или контракта.

Кроме того, язык поддерживает «инструкцию проверки» (своего рода «утверждение»), инварианты цикла и варианты цикла (которые гарантируют завершение цикла).

Пустота-безопасность

Защита от пустот, как и статическая типизация, является еще одним средством повышения качества программного обеспечения. Void-safe программное обеспечение защищено от ошибок времени выполнения, вызванных обращениями к недействительные ссылки, и поэтому будет более надежным, чем программное обеспечение, в котором могут происходить вызовы пустых целей. Полезна аналогия со статической типизацией. Фактически, возможность защиты от пустот можно рассматривать как расширение системы типов или шаг за пределы статической типизации, потому что механизм обеспечения защиты от пустот интегрирован в систему типов.

Защиту от недействительных целевых вызовов можно увидеть с помощью понятий прикрепления и (по расширению) отсоединения (например, ключевое слово detachable). Пустотно-безопасное средство можно увидеть в короткой переработке приведенного выше примера кода:

   some_attribute: съемный SOME_TYPE       use_some_attribute                - Установить значение some_attribute равным `v '.            делать                если прикрепил some_attribute в качестве l_attribute тогда                    сделай что-нибудь (l_attribute)                конец            конец        сделай что-нибудь (ценность: SOME_TYPE)                - Сделайте что-нибудь с `a_value '.            делать               ... делает что нибудь с `ценность' ...            конец

В приведенном выше примере кода показано, как компилятор может статически проверять надежность some_attribute будет прикреплен или отсоединен в точке использования. Примечательно, что прикрепил ключевое слово позволяет использовать "локальное вложение" (например, l_attribute), который ограничен только блоком кода, заключенным в конструкцию if-statement. Таким образом, в этом небольшом блоке кода локальная переменная (например, l_attribute) может быть статически гарантировано, что он недействителен (т. е. аннулирован).

Особенности: команды и запросы

Основной характеристикой класса является то, что он определяет набор функций: поскольку класс представляет набор объектов времени выполнения или «экземпляров», функция - это операция над этими объектами. Есть два типа функций: запросы и команды. Запрос предоставляет информацию об экземпляре. Команда изменяет экземпляр.

Различие команд и запросов важно для метода Эйфеля. Особенно:

• Принцип единого доступа: с точки зрения программного клиента, выполняющего вызов функции класса, не имеет значения, является ли запрос атрибутом (значением поля) или функцией (вычисляемым значением). Например, a_vehicle.speed может быть атрибутом, доступным для объекта транспортное средство, или это может быть вычислено функцией, которая делит расстояние на время. Обозначения одинаковы в обоих случаях, так что легко изменить реализацию класса, не затрагивая клиентское программное обеспечение.
• Принцип разделения команд и запросов: Запросы не должны изменять экземпляр. Это не языковое правило, а методологический принцип. Итак, в хорошем стиле Эйфеля нельзя найти функций «получить», которые что-то меняют и возвращают результат; вместо этого есть команды (процедуры) для изменения объектов и запросы для получения информации об объекте в результате предыдущих изменений.

Перегрузка

Эйфель не допускает аргументов перегрузка. Каждое имя функции в классе всегда сопоставляется с определенной функцией в классе. Одно имя в рамках одного класса означает одно. Этот выбор дизайна помогает читаемости классов, избегая причины неоднозначности в отношении того, какая процедура будет вызвана вызовом. Это также упрощает языковой механизм; в частности, это то, что делает возможным механизм множественного наследования Эйфеля.^[10]

Имена, конечно, можно повторно использовать в разных классах. Например, функция плюс (вместе с его инфиксом псевдоним "+") определяется в нескольких классах: ЦЕЛОЕ, НАСТОЯЩИЙ, НИТЬ, так далее.

Универсальность

Общий класс - это класс, который различается по типу (например, LIST [PHONE], список телефонных номеров; ACCOUNT [G-> ACCOUNT_TYPE], позволяющий ACCOUNT [SAVINGS] и ACCOUNT [CHECKING] и т. Д.). Классы могут быть универсальными, что означает, что они параметризованы по типам. Общие параметры указаны в квадратных скобках:

учебный класс СПИСОК [грамм] ...

G известен как «формальный общий параметр». (Эйфель резервирует «аргумент» для подпрограмм и использует «параметр» только для общих классов.) С таким объявлением G представляет внутри класса произвольный тип; поэтому функция может возвращать значение типа G, а процедура может принимать аргумент этого типа:

элемент: грамм делать ... конецположить (Икс: грамм) делать ... конец

В СПИСОК [INTEGER] и СПИСОК [СЛОВО] являются «родовыми производными» этого класса. Разрешенные комбинации (с n: INTEGER, w: WORD, il: LIST [INTEGER], wl: LIST [WORD]) находятся:

п := il.элементwl.положить (ш)

ЦЕЛОЕ и СЛОВО являются «фактическими универсальными параметрами» в этих универсальных производных.

Также возможно иметь «ограниченные» формальные параметры, для которых фактический параметр должен наследовать от заданного класса, «ограничение». Например, в

   учебный класс ХЕШ-ТАБЛИЦА [грамм, КЛЮЧ -> HASHABLE]

вывод HASH_TABLE [INTEGER, STRING] действительно только если НИТЬ наследуется от HASHABLE (как и в типичных библиотеках Eiffel). Внутри класса, имея КЛЮЧ сдерживается HASHABLE означает, что для x: КЛЮЧ можно обратиться к Икс все особенности HASHABLE, как в x.hash_code.

Основы наследования

Чтобы унаследовать от одного или нескольких других, класс будет включать наследовать пункт в начале:

учебный класс C наследовать   А   B- ... Объявление остальной части класса ...

Класс может переопределить (переопределить) некоторые или все унаследованные функции. Это должно быть явно объявлено в начале класса через переопределить подпункт пункта о наследовании, как в

учебный класс C наследовать    А        переопределить ж, грамм, час конец    B        переопределить ты, v конец

Видеть^[11] для полного обсуждения наследования Эйфеля.

Отложенные классы и функции

Классы могут быть определены с помощью отложенный класс а не с учебный класс чтобы указать, что класс не может быть создан напрямую. Классы, не поддерживающие создание экземпляров, называются абстрактные классы в некоторых других объектно-ориентированных языках программирования. На языке Эйфеля можно создать экземпляр только «эффективного» класса (он может быть потомком отложенного класса). Функцию также можно отложить, используя отложенный ключевое слово вместо делать пункт. Если у класса есть какие-либо отложенные функции, он должен быть объявлен как отложенный; однако класс без отложенных функций может, тем не менее, быть отложенным.

Отложенные классы играют в некоторой степени ту же роль, что и интерфейсы в таких языках, как Java, хотя многие теоретики объектно-ориентированного программирования считают, что интерфейсы сами по себе в значительной степени являются ответом на отсутствие множественного наследования в Java (которое есть у Eiffel).^[12][13]

Переименование

Класс, наследующий от одного или нескольких других, по умолчанию получает все свои функции под своими исходными именами. Однако он может изменить свои имена через переименовать статьи. Это требуется в случае множественного наследования, если есть конфликты имен между унаследованными функциями; без переименования результирующий класс нарушит указанный выше принцип отсутствия перегрузки и, следовательно, будет недействительным.

Кортежи

Типы кортежей можно рассматривать как простую форму класса, предоставляющую только атрибуты и соответствующую процедуру «установщика». Типичный тип кортежа читает

   ТУПЛ [имя: НИТЬ; масса: НАСТОЯЩИЙ; Дата: ДАТА]

и может быть использован для описания простого понятия записи о рождении, если класс не нужен. Экземпляр такого кортежа - это просто последовательность значений с заданными типами, указанными в скобках, например

   ["Бриджит", 3.5, Вчера вечером]

Доступ к компонентам такого кортежа можно получить, как если бы теги кортежа были атрибутами класса, например, если т был назначен указанный выше кортеж, тогда т. вес имеет значение 3,5.

Благодаря понятию команды назначителя (см. Ниже), точечная нотация также может использоваться для назначения компонентов такого кортежа, как в

   т.масса := т.масса + 0.5

Теги кортежа являются необязательными, поэтому также можно записать тип кортежа как ТУПЛ [СТРОКА, НАСТОЯЩЕЕ, ДАТА]. (В некоторых компиляторах это единственная форма кортежа, поскольку теги были введены в стандарте ECMA.)

Точная спецификация, например, ТУПЛ [A, B, C] в том, что он описывает последовательности по меньшей мере три элемента, первые три относятся к типам А, B, C соответственно. Как результат, ТУПЛ [A, B, C] соответствует (может быть назначен) ТУПЛ [A, B], к ТУПЛ [A] и чтобы ТУПЛ (без параметров), самый верхний тип кортежа, которому соответствуют все типы кортежа.

Агенты

Механизм «агента» Эйфеля превращает операции в объекты. Этот механизм можно использовать для итерации, событийно-ориентированное программирование и другие контексты, в которых полезно передавать операции по структуре программы. Другие языки программирования, особенно те, которые подчеркивают функциональное программирование, разрешите аналогичный шаблон, используя продолжения, закрытие, или же генераторы; Агенты Эйфеля подчеркивают объектно-ориентированную парадигму языка и используют синтаксис и семантику, аналогичные блокам кода в Болтовня и Рубин.

Например, чтобы выполнить my_action блок для каждого элемента мой список, можно было бы написать:

   мой список.сделай все (агент my_action)

Выполнить my_action только на элементах, удовлетворяющих my_condition, можно добавить ограничение / фильтр:

   мой список.do_if (агент my_action, агент my_condition)

В этих примерах my_action и my_condition рутина. Добавляя к ним префикс агент дает объект, который представляет соответствующую подпрограмму со всеми ее свойствами, в частности, с возможностью вызова с соответствующими аргументами. Так что если а представляет этот объект (например, потому что а аргумент в пользу сделай все), Инструкция

   а.вызов ([Икс])

вызовет исходную процедуру с аргументом Икс, как если бы мы напрямую вызвали исходную процедуру: my_action (x). Аргументы в пользу вызов передаются как кортеж, здесь [Икс].

Можно оставить аргументы агенту открыто и сделать других закрыто. Открытые аргументы передаются как аргументы в вызов: они предоставляются во время использование агента. Закрытые аргументы предоставляются во время агента определение. Например, если действие2 имеет два аргумента, итерация

   мой список.сделай все (агент действие2 (?, у))

повторяет действие2 (х, у) для последовательных значений Икс, где второй аргумент остается равным у. Знак вопроса ? указывает на открытый аргумент; у - закрытый аргумент агента. Обратите внимание, что основной синтаксис агент f это сокращение для агент f (?,?, ...) со всеми открытыми аргументами. Также возможно сделать цель агента, открытого через обозначение {T}? куда Т это тип цели.

Различие между открытыми и закрытыми операндами (операнды = аргументы + цель) соответствует различию между связанными и свободными переменными в лямбда-исчисление. Выражение агента, такое как действие2 (?, y) с некоторыми операндами закрытыми, а некоторые открытыми соответствуют версии исходной операции карри на закрытых операндах.

Механизм агента также позволяет определять агента без ссылки на существующую процедуру (например, my_action, my_condition, действие2) через встроенные агенты, как в

мой список.сделай все (агент (s: НИТЬ)     требовать         not_void: s /= Пустота     делать         s.append_character (',')     гарантировать         добавлен: s.считать = Старый s.считать + 1     конец)

Переданный здесь встроенный агент может иметь все атрибуты обычной процедуры, включая предварительное условие, постусловие, предложение восстановления (здесь не используется) и полную подпись. Это позволяет избежать определения подпрограмм, когда все, что нужно, - это вычисления, которые должны быть заключены в агент. Это полезно, в частности, для контрактов, как в инвариантном предложении, которое выражает, что все элементы списка положительны:

   мой список.для всех (агент (Икс: ЦЕЛОЕ): BOOLEAN делать Результат := (Икс > 0) конец)

Текущий механизм агента оставляет возможность ошибки типа времени выполнения (если подпрограмма с п аргументы передаются агенту, ожидающему м аргументы с м < п). Этого можно избежать с помощью проверки во время выполнения с помощью предварительного условия valid_arguments из вызов. Доступно несколько предложений по чисто статическому исправлению этой проблемы, в том числе предложение об изменении языка Рибет и др.^[14]

Однажды рутины

Результат процедуры можно кэшировать с помощью однажды ключевое слово вместо делать. Не первые вызовы подпрограммы не требуют дополнительных вычислений или выделения ресурсов, а просто возвращают ранее вычисленный результат. Распространенным шаблоном для «однократных функций» является предоставление общих объектов; первый вызов создаст объект, последующие вернут ссылку на этот объект. Типичная схема:

shared_object: SOME_TYPE    однажды        Создайте Результат.делать (аргументы)             - Это создает объект и возвращает ссылку на него через `Result '.    конец

Возвращенный объект—Результат в примере - сам может быть изменяемым, но его ссылка остается той же.

Часто «однократные подпрограммы» выполняют требуемую инициализацию: несколько вызовов библиотеки могут включать вызов процедуры инициализации, но только первый такой вызов будет выполнять требуемые действия. С помощью этого шаблона инициализацию можно децентрализовать, избегая необходимости в специальном модуле инициализации. «Обычные процедуры» аналогичны по назначению и действию одноэлементный образец на многих языках программирования, а также Образец борга используется в Python.

По умолчанию вызывается «однократная процедура». один раз на поток. Семантику можно настроить на один раз за процесс или же один раз на объект уточняя его с помощью «однократного ключа», например один раз ("ПРОЦЕСС").

Конверсии

Eiffel предоставляет механизм, позволяющий преобразовывать различные типы. Механизмы сосуществуют с наследованием и дополняют его. Чтобы избежать путаницы между двумя механизмами, в конструкции используется следующий принцип:

(Принцип преобразования) Тип не может одновременно соответствовать и преобразовывать в другой.

Например, ГАЗЕТА может соответствовать ПУБЛИКАЦИЯ, но ЦЕЛОЕ превращается в НАСТОЯЩИЙ (и не наследует от него).

Механизм преобразования просто обобщает специальные правила преобразования (например, между ЦЕЛОЕ и НАСТОЯЩИЙ), которые существуют в большинстве языков программирования, что делает их применимыми к любому типу, если соблюдается вышеуказанный принцип. Например, ДАТА класс может быть объявлен для преобразования в НИТЬ; это позволяет создать строку из даты просто через

   my_string := мое свидание

как ярлык для использования явного создания объекта с процедурой преобразования:

   Создайте my_string.make_from_date (мое свидание)

Чтобы первая форма стала синонимом второй, достаточно перечислить процедуру создания (конструктор) make_from_date в конвертировать предложение в начале класса.

В качестве другого примера, если существует такая процедура преобразования, указанная в TUPLE [день: INTEGER; месяц: STRING; год: INTEGER], то можно напрямую присвоить кортеж дате, вызывая соответствующее преобразование, как в

      День взятия Бастилии := [14, "Июль", 1789]

Обработка исключений

Обработка исключений в Eiffel строится на принципах контрактного проектирования. Например, исключение возникает, когда вызывающая подпрограмма не может удовлетворить предварительное условие или когда процедура не может гарантировать обещанное постусловие. В Eiffel обработка исключений не используется для поток управления или исправить ошибки ввода данных.

Обработчик исключений Eiffel определяется с помощью спасать ключевое слово. В рамках спасать раздел, повторить попытку ключевое слово снова выполняет процедуру. Например, следующая подпрограмма отслеживает количество попыток выполнения подпрограммы и повторяет попытки только определенное количество раз:

connect_to_server (сервер: РАЗЪЕМ)      - Подключитесь к серверу или откажитесь после 10 попыток.    требовать        сервер /= Пустота а потом сервер.адрес /= Пустота    местный        попытки: ЦЕЛОЕ    делать        сервер.соединять    гарантировать      связаны: сервер.подключен    спасать        если попытки < 10 тогда            попытки := попытки + 1            повторить попытку        конец    конец

Однако этот пример, вероятно, ошибочен для чего-либо, кроме простейших программ, поскольку следует ожидать сбоя соединения. Для большинства программ стандартное имя вроде try_connecting_to_server было бы лучше, и постусловие не обещало бы соединения, оставляя вызывающей стороне возможность предпринять соответствующие шаги, если соединение не было открыто.

Параллелизм

Доступен ряд сетевых и потоковых библиотек, таких как EiffelNet и EiffelThreads. Модель параллелизма для Eiffel, основанная на концепции проектирования по контракту, является SCOOP, или же Простое параллельное объектно-ориентированное программирование, еще не входит в определение официального языка, но доступно в EiffelStudio.КАМЕЯ^[15] является (нереализованным) вариантом SCOOP для Eiffel. Параллелизм также взаимодействует с исключениями. Асинхронные исключения могут быть проблематичными (когда процедура вызывает исключение после того, как ее вызывающая сторона завершила свою работу).^[16]

Синтаксис оператора и скобки, команды назначения

Взгляд Эйфеля на вычисления полностью объектно-ориентирован в том смысле, что каждая операция относится к объекту, «цели». Так, например, такое дополнение, как

а + б

концептуально понимается, как если бы это был вызов метода

а.плюс (б)

с целью а, особенность плюс и аргумент б.

Конечно, первый является обычным синтаксисом и обычно предпочтительнее. Синтаксис оператора позволяет использовать любую форму, объявляя функцию (например, в ЦЕЛОЕ, но это применимо к другим базовым классам и может использоваться в любых других, для которых подходит такой оператор):

плюс псевдоним "+" (Другой: ЦЕЛОЕ): ЦЕЛОЕ        - ... Обычное объявление функции ...    конец

Диапазон операторов, которые можно использовать в качестве «псевдонимов», довольно широк; они включают предопределенные операторы, такие как «+», а также «свободные операторы», состоящие из не буквенно-цифровых символов. Это позволяет разрабатывать специальные инфиксные и префиксные обозначения, например, в математических и физических приложениях.

Каждый класс может дополнительно иметь один функция с псевдонимом "[]", оператор "скобки", что позволяет использовать обозначение а [я, ...] как синоним а.ф (я, ...) куда ж - выбранная функция. Это особенно полезно для контейнерных структур, таких как массивы, хеш-таблицы, списки и т.д. Например, доступ к элементу хеш-таблицы со строковыми ключами можно записать

   номер := телефонная книга ["ДЖИЛЛ СМИТ"]

«Команды-назначители» - это вспомогательный механизм, разработанный в том же духе, позволяющий переосмыслить устоявшиеся и удобные обозначения в рамках объектно-ориентированного программирования. Команды присваивания позволяют схожему с присваиванием синтаксису вызывать процедуры «установщика». Собственно задание никогда не может иметь форму a.x: = v поскольку это нарушает сокрытие информации; вам нужно использовать команду (процедуру) установки. Например, класс хэш-таблицы может иметь функцию и процедуру

элемент псевдоним "[]" (ключ: НИТЬ): ЭЛЕМЕНТ         [3]      - Элемент ключа "ключ".      - ("Getter" запрос)    делать        ...    конецположить (е: ЭЛЕМЕНТ; ключ: НИТЬ)      - Вставьте элемент `e ', связав его с ключом` key'.      - (команда "Сеттер")    делать        ...    конец

Затем, чтобы вставить элемент, вы должны использовать явный вызов команды setter:

   [4] телефонная книга.положить (Новый человек, "ДЖИЛЛ СМИТ")

Это можно записать эквивалентно как

   [5] телефонная книга ["ДЖИЛЛ СМИТ"] := Новый человек

(так же, как phone_book ["ДЖИЛЛ СМИТ"] это синоним number: = phone_book.item ("ДЖИЛЛ СМИТ")), при условии объявления элемент теперь начинается (замена [3]) с

   элемент псевдоним "[]" (ключ: НИТЬ): ЭЛЕМЕНТ назначать положить

Это заявляет положить в качестве команды назначителя, связанной с элемент и в сочетании с псевдонимом скобок делает [5] допустимым и эквивалентным [4]. (Это также можно было бы записать, не используя скобку, как phone_book.item ("ДЖИЛЛ СМИТ"): = New_person.

примечание: список аргументов назначителя a должен быть следующим: (тип возвращаемого значения; весь список аргументов a ...)

Лексические и синтаксические свойства

В Eiffel регистр не учитывается. Жетоны делать, делать и ДЕЛАТЬ все обозначают один и тот же идентификатор. См., Однако, «правила стиля» ниже.

Комментарии вводятся -- (два последовательных тире) и продолжаются до конца строки.

Точка с запятой в качестве разделителя инструкций не обязательна. В большинстве случаев точка с запятой просто опускается, за исключением разделения нескольких инструкций в строке. В результате на странице программы меньше загромождений.

Нет вложенности объявлений функций и классов. В результате структура класса Eiffel проста: некоторые предложения уровня класса (наследование, инвариант) и последовательность объявлений функций - все на одном уровне.

Принято группировать функции в отдельные «разделы функций» для большей читабельности, при этом стандартный набор тегов основных функций появляется в стандартном порядке, например:

учебный класс ХЕШ-ТАБЛИЦА [ЭЛЕМЕНТ, КЛЮЧ -> HASHABLE] наследовать СТОЛ [ЭЛЕМЕНТ]    особенность - Инициализация         - ... Объявления команд инициализации (процедуры / конструкторы создания) ...    особенность -- Доступ         - ... Объявления небулевых запросов к состоянию объекта, например элемент ...    особенность -- Отчет о состоянии дел         - ... Объявления логических запросов о состоянии объекта, например пусто ...    особенность - Смена элемента         -- ... Declarations of commands that change the structure, e.g. положить ...    -- etc.конец

В отличие от большинства 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 (СПИСОК), all-lower-case for feature names (делать), and initial capitals for constants (Авогадро). 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 курсив, comments, operators, and punctuation marks in Римский, with program text in синий 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:

учебный класс    HELLO_WORLDСоздайте    делатьособенность    делать       делать          Распечатать ("Привет, мир!")       конецконец

Interfaces to other tools and languages

Eiffel is a purely object-oriented language but provides an открытая архитектура 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).

Although there is no direct connection between Eiffel and C, many Eiffel компиляторы (Visual Eiffel is one exception) output C исходный код как intermediate language, to submit to a C compiler, for оптимизация и переносимость. 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 in order to obtain optimized native code. On .NET, the EiffelStudio compiler directly generates CIL (Common Intermediate Language) code. В SmartEiffel compiler can also output Байт-код Java.

Рекомендации

внешняя ссылка

• Eiffel Software web site of the company that introduced Eiffel, was Interactive Software Engineering (ISE).