Oxygene (язык программирования)

Материал из Национальной библиотеки им. Н. Э. Баумана
Последнее изменение этой страницы: 00:02, 22 мая 2016.
Oxygene
FileOxygene.png
Спроектировано RemObjects Software
Первый   появившийся 7.1.73 / April 23, 2014
Расширение файла .oxygene
Портал: www.elementscompiler.com
Под влиянием
Object Pascal, C#

Oxygene ("Кислород") (раньше известный как Chrome) - это язык программирования, разработанный RemObjects Software для Microsoft's Common Language Infrastructure и Java Platform. Oxygene основан на Object Pascal, но также испытал влияние C#, Eiffel, Java, F# и других языков.

По сравнению с устаревшим Delphi.NET Oxygene придает особого значение полной обратной совместимости, но был разработан для переконструирования языка, чтобы подходить управляемым платформам разработки и усиливать особенности и технологии, поставляемые .NET и Java.

Oxygene предлагает полную интеграцию с Visual Studio 2010 и 2012 как комменрческий продукт и свободно доступный компилятор командной строки. Начиная с 2008 года, RemObjects Software предоставили свой компилятор и технология IDE компании Embarcadero, чтобы использовать его в продукте Embarcadero - Prism[1]. С осени 2011 года Oxygene доступен в двух отдельных изданиях, во втором издании добавлена поддержка для Java и Android. После релиза XE4 Embarcadero Prism более не является частью RAD Studio SKU. Существуют многочисленные пути поддержки и обновлений для пользователей Prism для перехода на Oxygene.

История

Программное обеспечение RemObjects возникло на фоне Delphi[2]. В 2002 году RemObjects пытались расширить свои библиотеки в Microsoft .NET Framework и, естественно, они рассчитывали использовать Delphi для работы в .NET. Согласно RemObjects Chief Architect казалось, будто "Borland разработал Delphi для .NET с одной главной целью: спрятать от разработчиков переход от Win32 к .NET". В результате Delphi для .NET "представил много черт Delphi и Win32, что оказалось неуместным и странным в мире .NET"

В результате RemObjects решили использовать c# для своих .NET проектом вместо Delphi. Но их разработчики скучали по синтаксису Pascal, поэтому в конечном счете RemObjects решили создать язык для .NET с синтаксисом Pascal, и так родился Oxygene. Его кодовым именем было Adrenochrome, которое позже сократилось до Chrome, и в итоге было переименовано в Oxygene.

Конструкция

Язык программирвания произошел от Delphi и Object Pascal, но был разработан, чтобы отражать парадигму программирования .NET и производить CLR-скомпилированнмые сборки.

Новые черты языка в Oxygene 3.0 включают в себя поддержку параллельного программирования, сообщения свойств для паттерна MVC, неопределенные выражения и улучшенный инструкментрий QA анализа.

Особенности

Oxygene это полностью объектно-ориентированный язык, что позволяет разработчикам писать код, которые может быть запущен на .NET/Mono, Java/Android or Objective-C Runtime Environments. Он основан и простроен на структурах языка Pascal и Object Pascal[3].

Oxygene генерирует код с использованием сборщика мусора (GC) в .NET и Java и автоматического подсчета ссылок (ARC) в Objective-C. Это значит, что независимо от платформы управление временами жизни переменных находится код контролем без явного кода разработчика, хотя определенная базовая семантика может немного отличаться.

  • Структура программы

В Oxygene не используются "модули" как в Delphi, но используются пространства имен .NET, чтобы организовывать и группировать типы. Пространство имен может охватывать несколько файлов (и сборок), но и в одном файле могут содержаться различные пространства имен. Это просранство имен определено в самом начале файла:

namespace ConsoleApplication1;

Файлы в Oxygene разделены на секции интерфейса и реализации, структура знакомая нам из Delphi. Интерфейс следует объявлениям в пространстве имен. Он содержит выражение uses, с помощью которого Oxygene инпортирует типы из других пространств имен:

uses
  System.Linq;

Импортированные пространства имен должны находиться в проекте или в сборке. В отличие от C#, Oxygene псевдо имена не могут быть определены для пространств имен, только для единичных типов (см. ниже).

Следуя выражению uses, файл содержит объявления типов, как и в Delphi:

interface

type
  ConsoleApp = class
  public
    class method Main;
  end;

Как в C# метод Main является точкой входа для любой программы. Он может принимать параметры args: массив строк для передачи аргументов из командной строки в программу.

Больше типов может быть объявлено без повторения ключевого слова типа.

Реализация объявленных методов помещены в секцию реализации:

implementation

class method ConsoleApp.Main;
begin
  // add your own code here
  Console.WriteLine('Hello World.');
end;

end.

Файл всегда кончается end.

  • Классы

Так как Oxygene - объектно-ориентированный язык, большинство кода находится в классах. Классы являются слиянием данных и относящейся к ним функциональности, может состоять из полей, методов, свойств и широковещательных событий (в .NET).

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

type
  MyBetterButton = class(Button)
    … 
  end;

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

Вдобавок к членам, классы также могут определять инварианты, которые помогут связности класса во время выполнения. Инварианты это логические утверждения, описывающие допустимое состояние объекта, и компилятор автоматически гарантирует, что инварианты будут проверены, когда это необходимо, заранее определяя недействительные состояния объекта и программные ошибки, которые они вызывают. Инварианты - это половина реазиации класса Contracts в Oxygene. Индивидуальные экземпляры классов называются объектами.

  • Методы

Масса кода в проекте - это тела методов классов. Тело метода ограничено ключевыми словами "begin" и "end" и может содержать список утверждений, разделенные точкой с запятой, которые будут выполнены в порядке следования при вызове метода.

Вдобавок к обычным утверждениям, таким как вызовы других методов, присвоение и арифметические вычисления, Oxygene предоставлет широкий ряд конструкций, определяющих логику программы, такие как for/to, for/each, while, repeat/until и бесконечные циклы, "if" and "case", присвоения и методы классов.

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

var x := 5 + 9;
(5 + 9).ToString;

утверждение "5 + 9" это выражение, которое применяется оператор "+" к значениям "5" и "9". Результат выражения моет быть использован далее, например присвоен переменной "X" или использован в качестве параметра в методе "ToString".

Не все утверждения являются выражениями, поэтому следующий пример недействителен:

var y := Console.WriteLine("Hello");

потому что вызов "Console.WriteLine" это утверждения без возвращаемого значения.

Система типов в Oxygen очень глубокая, что означает, что каждый тип в конечном счете наследуется из базового класса "Object". Oxygene автоматически упаковывает и распаковывает так называемые простые типы - такие как простые числа - по мере необходимости, в большинстве случаев делая различия между объектами и простыми типами несущественными для разработчика Oxygene. Oxygene также поддерживает концепцию "нулевых" простых типов. Такие типы полностью поддерживаются в выражениях.

  • Другие типы

Oxygene также поддерживает ряд значимых типов, которые не находятся в классах внутренних типов - хотя, их экземпляры мгут быть рассмотрены как объекты. Они включаются в себя "Enums" Для определения группы различных связанных между собой значений, "Arrays", которые содержат пронумерованные списки элементов, доступных по индексу, и "Sequences", которые также содержат список элементов, которые доступны последовательно не по индексу.

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

  • Пространства имен

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

namespace Foo; // default "current" namespace for types in this file
…
type
	MyType = class … end; // "Foo.MyType"
	… 
	Bar.MyOtherType = class … end; // "Bar.MyOtherType"

Обращаясь (т.е. используя) к типу, их имена могут быть заданы с использованием полного имени, короткое имя может быть использовано, если тип существует в текущем пространстве имен или это пространство указано в выражении uses:

namespace Foo;
…
uses Bar;
…
var x: MyOtherType; // finds "Bar.MyOtherType"
  • Обобщенные классы

Обобщенные классы являются основным признаком совеременных языков программирования, и Oxygene предоставляет их полную поддержку и в .NET, и Java.

Проще говоря, обобщенные классы позволяют разработчику объявлять классы, которые сторого используют другие типы без знания точного типа во время реализации. Обычным примером является класс Список, который может быть использован в различных воплощениях, чтобы поддерживать различные типы - например, список целых чисел (IntegerList), список строк (StringList) или список специальных типов пользователя (FooList).

Вместо того, чтобы реализовывать IntegerList, StringList и FooList по отдельности (дублируя большое количество кода) или возвращаться к простому списку нетипизированных объектов (который теряет безопасность типа и требует лишние приведения типов при доступе к элементам), может быть определен обобщенный список List, где T это заполнитель для любого типа.

Во всех реализациях List имя T может быть использовано для обращенияк "типу, который установлен в этом списке" без конкретизации. (Конечно, обощенные типы могут налагать ограничения на свои типы, например вOrderList можно указать, чтобы его члены должны реализовать интерфейс, который их сортирует).

При его использовании можно установить конкретный вид обобщенного класса, просто указав его имя типа, т.е.:

var x := new List<Int32>;
var y := new List<String>;

и затем работать с этими списками через "x" и "y", они могут быть получены с безопасно, потому что все члены списка Int32 и String соответственно.

  • Последовательности и очереди

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

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

Последовательности также могут представлять нестатические данные, которые получены или созданы на лету, так как последовательности пронумерованы. Например, можно реализовать последовательность, которая считает все числа Пи или получает заголовки RSS, загруженные с сервера.

В Oxygene последовательности представляют собой последовательность ключевых слов (аналогично синтаксису массива), поэтому переменная, содержащая в себе последовательность строк, может быть определена следующим образом:

var Names: sequence of String;

Определенная таким образом переменная будет способна относиться к любому виду последовательностей - будет это массив, стандартно сгенерированная коллекция списков или специальная коллекция.

Очередь предоставляет синтаксис,схожий с SQL, для исполнения действий или применения фильтров к последовательностям - например, чтобы сузить последовательность к элементам с конкретным значением или отсортировать последовательность, используя свойство:

var byLength := from n in Names order by n.Length;
  • Кортежи

Oxygene 5.2 также расширяет язык Oxygene поддержкой типов кортежей и для .NET, и для Java. Кортежи являются новым основным типом в языке, как массивы или последовательности, и они созданы, чтобы содержать в себе специфические объекты.

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

Вы можете определить переменную типа кортеж следующим образом:

var t: tuple of (String, Int32, Boolean);

и получить доступ к отдельным его членам, используя сторого типизированный индексатор []:

var s := t[0];
var i := t[1];

в котором каждый индекс строго типизировать, т.е. компилятор знает, что t[1] это число Int32. Вы можете также определить кортежи, используя ():

t := ('Holla', 23, false);

и даже разбить кортежи на отдельные значения:

var s: String;
var i: Int32;
(s, i) := MyTupleMethod();

Различия между Delphi и Oxygene

  • unit: заменены пространствами имен. Так как Oxygene не компилирует файл за файлом и проект за проектом, он не основывается на именах файлов. Вместо модулей ключевое слово пространства имен используется для различия пространства имен по умолчанию, в котором определены все типы для процедур и функций: метод - предпочитаемое слово , однако процедура или функция до сих пор работает.
  • overload: в Oxygene все методы перегружены по умолчанию, поэтому никаких специальных ключевых слов не требует для this.Create(): этот вызов конструктора был заменен новым ключевым словом. Он до сих пор может быть установлен в опциях проекта для сохранения совместимости.
  • string: Символы в строках начинаются с нуля и доступны только для чтения. Строки могут иметь нулевые значения, поэтому тестирование строк на пустоте более не нужно.

Критика

Некоторые люди любят переносить их Win32 Delphi код в Oxygene таким, какой он есть. Это невозможно, в то время как Oxygene выглядит как Delphi, есть достаточно изменений, что делает невозможной легкую перекомпиляцию. В то время как кажется, что Oxygene возник, чтобы дать новое воплощение другой версии Delphi, это совершенно неверно. Возможно связи поддерживаются для маркетинговых целей (REMObjects до сихпор является частью ISV Delphi), как Component Pascal назвался Pascal.

Самым главным различием языков является то, что фреймворк Visual Component Library не доступен для Delphi Prism[4]. Это затрудняет перенос кода, так как классический Delphi сильно зависит от VCL.

Примечания

Ссылки

  1. Википедия

http://www.elementscompiler.com/elements/oxygene/default.aspx www.elementscompiler.com