View source for Oxygene (programming language)

{{Short description|Object Pascal-based programming language}}
{{Infobox programming language
| name = Oxygene
| logo = Chrome-128.png
| paradigm = 
| year = {{start date and age|2005}}<ref>{{Cite web |url=https://www.elementscompiler.com/elements/oxygene/history.aspx |title=Evolution of the Oxygene Language &#124; Oxygene &#124; Elements |access-date=2018-01-04 |archive-date=2018-01-05 |archive-url=https://web.archive.org/web/20180105180341/https://www.elementscompiler.com/elements/oxygene/history.aspx |url-status=live }}</ref>
| designer = 
| developer = RemObjects Software
| latest_release_version = <!-- WikiData -->
| latest_release_date = <!-- WikiData -->
| latest_test_version = 
| latest_test_date = 
| typing = 
| implementations = 
| dialects = 
| influenced_by = [[Software:Delphi|Delphi]]'s [[Object Pascal]], [[C Sharp (programming language)|C#]]
| influenced = 
| platform = [[Common Language Infrastructure]], [[Software:Java (software platform)|Java]], Cocoa, CPU-Native, [[Software:Windows|Windows]] 32/64 bit, [[Software:Linux|Linux]] 32/64 bit, [[WebAssembly]]
| license = Trialware
| website = {{URL|https://elementscompiler.com/elements/oxygene/}}
}}

'''Oxygene''' (formerly known as '''Chrome''') is a [[Programming language|programming language]] developed by RemObjects Software for [[Company:Microsoft|Microsoft's]] [[Common Language Infrastructure]], the [[Software:Java (software platform)|Java]] Platform and Cocoa. Oxygene is based on [[Delphi (programming language)|Delphi]]'s [[Object Pascal]], but also has influences from  [[C Sharp (programming language)|C#]], [[Eiffel (programming language)|Eiffel]], [[Java (programming language)|Java]], [[F Sharp (programming language)|F#]] and other languages.

Compared to the now deprecated [[Delphi (programming language)|Delphi.NET]], Oxygene does not emphasize total backward compatibility, but is designed to be a "reinvention" of the language, be a good citizen on the managed development platforms, and leverage all the features and technologies provided by the .NET and Java runtimes.

Oxygene is a commercial product and offers full integration into [[Company:Microsoft|Microsoft]]'s [[Software:Visual Studio|Visual Studio]] IDE on Windows, as well as its own IDE called Fire for use on [[Software:MacOS|macOS]]. Oxygene is one of six languages supported by the underlying Elements Compiler toolchain, next to [[C Sharp (programming language)|C#]], [[Swift (programming language)|Swift]], [[Java (programming language)|Java]], [[Go (programming language)|Go]] and [[Mercury (Modern Visual Basic - programming language)|Mercury]] (based on [[Visual Basic .NET|Visual Basic.NET]]).

From 2008 to 2012, RemObjects Software licensed its compiler and IDE technology to [[Company:Embarcadero Technologies|Embarcadero]] to be used in their Embarcadero Prism product.<ref>{{cite web|url=https://www.embarcadero.com/products/prism|title=Embarcadero Prism page, at the bottom of the page an image stating it is powered by RemObjects Oxygene|access-date=2011-12-14|archive-date=2011-12-27|archive-url=https://web.archive.org/web/20111227171846/https://www.embarcadero.com/products/prism|url-status=live}}</ref> Starting in the Fall of 2011, Oxygene became available in two separate editions, with the second edition adding support for the Java and Android runtimes.  Starting with the release of XE4, Embarcadero Prism is no longer part of the RAD Studio SKU. Numerous support and upgrade paths for Prism customers exist to migrate to Oxygene.<ref>{{Cite web |url=https://blogs.remobjects.com/blogs/mh/2013/04/17/p5822 |title=Prism XE4, Where Art Thou? &#124; RemObjects Blogs |access-date=2013-06-06 |archive-url=https://web.archive.org/web/20130620145521/https://blogs.remobjects.com/blogs/mh/2013/04/17/p5822 |archive-date=2013-06-20 |url-status=dead }}</ref> As of 2016, there is only one edition of Oxygene, which allows development on Windows or macOS, and which can create executables for Windows, Linux, WebAssembly .NET, iOS, Android, Java and macOS.

== The language ==
The Oxygene language has its origins in Object Pascal in general and Delphi in particular, but was designed to reflect the guidelines of .NET programming and to create fully CLR-compliant assemblies. Therefore, some minor language features known from Object Pascal / Delphi have been dropped or revised, while a slew of new and more modern features, such as Generics or Sequences and Queries have been added to the language.

Oxygene is an [[Object-oriented programming|object-oriented]] language, which means it uses classes, which can hold data and execute code, to design programs.{{clarify|date=July 2014}} Classes are "prototypes" for objects, like the idea of an apple is the prototype for the apple one can actually buy in a shop. It is known that an apple has a colour, and that it can be peeled: those are the data and executable "code" for the apple class.

Oxygene provides language-level support for some features of parallel programming. The goal is to use all cores or processors of a computer to improve performance. To reach this goal, tasks have to be distributed among several threads. The .NET Framework's <code>ThreadPool</code> class offered a way to efficiently work with several threads. The Task Parallel Library (TPL) was introduced in .NET 4.0 to provide more features for parallel programming.

Operators can be overloaded in Oxygene using the <code>class operator</code> syntax:

<source lang="delphi">class operator implicit(i : Integer) : MyClass;</source>

Note, that for [[Operator overloading|operator overloading]] each operator has a name, that has to be used in the operator overloading syntax, because for example "+" would not be a valid method name in Oxygene.<ref>{{Cite web |url=https://prismwiki.codegear.com/en/Operator_Overloading |title=Operator Overloading - Delphi Prism |access-date=2010-01-09 |archive-url=https://web.archive.org/web/20110708174151/https://prismwiki.codegear.com/en/Operator_Overloading |archive-date=2011-07-08 |url-status=dead }}</ref>

=== Program structure ===
Oxygene does not use "Units" like Delphi does, but uses .NET namespaces to organize and group types. A namespace can span multiple files (and assemblies), but one file can only contain types of one namespace. This namespace is defined at the very top of the file:
 namespace ConsoleApplication1;

Oxygene files are separated into an interface and an implementation section, which is the structure known from Delphi. The interface section follows the declaration of the namespace. It contains the <code>uses</code> clause, which in Oxygene imports types from other namespaces:
<source lang="delphi">
uses
  System.Linq;
</source>
Imported namespaces have to be in the project itself or in referenced assemblies. Unlike in C#, in Oxygene alias names cannot be defined for namespaces, only for single type names (see below).

Following the <code>uses</code> clause a file contains type declarations, like they are known from Delphi:
<source lang="delphi">
interface

type
  ConsoleApp = class
  public
    class method Main;
  end;</source>
As in C#, the Main method is the entry point for every program. It can have a parameter <code>args : Array of String</code> for passing command line arguments to the program.

More types can be declared without repeating the <code>type</code> keyword.

The implementation of the declared methods is placed in the implementation section:
<source lang="delphi">
implementation

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

end.</source>
Files are always ended with <code>end.</code>

=== Types ===
As a .NET language, Oxygene uses the .NET type system: There are value types (like structs) and reference types (like arrays or classes).

Although it does not introduce own "pre-defined" types, Oxygene offers more "pascalish" generic names for some of them,<ref>{{Cite web |url=https://prismwiki.codegear.com/en/Built-In_Types |title=Built-In Types - Delphi Prism |access-date=2010-01-10 |archive-url=https://web.archive.org/web/20110708174159/https://prismwiki.codegear.com/en/Built-In_Types |archive-date=2011-07-08 |url-status=dead }}</ref> so that for example the <code>System.Int32</code> can be used as <code>Integer</code> and <code>Boolean</code> (<code>System.Boolean</code>), <code>Char</code> (<code>System.Char</code>), <code>Real</code> (<code>System.Double</code>) join the family of pascal-typenames, too. The struct character of these types, which is part of .NET, is fully preserved.

As in all .NET languages types in Oxygene have a visibility. In Oxygene the default visibility is <code>assembly</code>, which is equivalent to the <code>internal</code> visibility in C#. The other possible type visibility is <code>public</code>.
<source lang="delphi">
type
  MyClass = public class
end;
</source>
The visibility can be set for every type defined (classes, interfaces, records, ...).

An alias name can be defined for types, which can be used locally or in other Oxygene assemblies.
<source lang="delphi">
type
  IntList = public List<Integer>; //visible in other Oxygene-assemblies
  SecretEnumerable = IEnumerable<String>; //not visible in other assemblies
</source>
Public type aliases won't be visible for other languages.

==== Records ====
Records are what .NET structs are called in Oxygene. They are declared just like classes, but with the <code>record</code> keyword:
<source lang="delphi">
type
  MyRecord = record
    method Foo;
  end;</source>
As they're just .NET structs, records can have fields, methods and properties, but do not have [[Inheritance (object-oriented programming)|inheritance]] and cannot implement [[Interface (object-oriented programming)|interface]]s.

=== Interfaces ===
Interfaces are a very important concept in the .NET world, the framework itself makes heavy use of them. Interfaces are the specification of a small set of methods, properties and events a class has to implement when implementing the interface. For example, the interface <code>IEnumerable<T></code> specifies the <code>GetEnumerator</code> method which is used to iterate over sequences.

Interfaces are declared just like classes:
<source lang="delphi">
type
  MyInterface = public interface
    method MakeItSo : IEnumerable;
    property Bar : String read write;
  end;</source>
Please notice, that for properties the getter and setter are not explicitly specified.

=== Delegates ===
Delegates define signatures for methods, so that these methods can be passed in parameters (e.g. callbacks) or stored in variables, etc. They're the type-safe NET equivalent to function pointers. They're also used in events. When assigning a method to a delegate, one has to use the <code>@</code> operator, so the compiler knows, that one doesn't want to call the method but just assign it.

Oxygene can create anonymous delegates; for example methods can be passed to the <code>Invoke</code> method of a control without declaring the delegate:
<source lang="delphi" highlight="1">
method MainForm.MainForm_Load(sender: System.Object; e: System.EventArgs);
begin
  Invoke(@DoSomething);
end;</source>
An anonymous delegate with the signature of the method <code>DoSomething</code> will be created by the compiler.

Oxygene supports polymorphic delegates, which means, that delegates which have parameters of descending types are assignment compatible. Assume two classes <code>MyClass</code> and <code>MyClassEx = class(MyClass)</code>, then in the following code <code>BlubbEx</code> is assignment compatible to <code>Blubb</code>.
<source lang="delphi">
type
  delegate Blubb(sender : Object; m : MyClass);
  delegate BlubbEx(sender : Object; mx : MyClassEx);</source>

Fields can be used to delegate the implementation of an interface, if the type they're of implements this interface:
<source lang="delphi">
Implementor = public class(IMyInterface)
  // ... implement interface ...
end;

MyClass = public class(IMyInterface)
  fSomeImplementor : Implementor; public implements IMyInterface; //takes care of implementing the interface
end;</source>
In this example the compiler will create public methods and properties in <code>MyClass</code>, which call the methods / properties of <code>fSomeImplementor</code>, to implement the members of IMyInterface. This can be used to provide mixin-like functionality.<ref>{{Cite web |url=https://prismwiki.codegear.com/en/Provide_Mixin-like_functionality |title=Provide Mixin-like functionality - Delphi Prism |access-date=2010-01-17 |archive-url=https://web.archive.org/web/20110708174212/https://prismwiki.codegear.com/en/Provide_Mixin-like_functionality |archive-date=2011-07-08 |url-status=dead }}</ref>

=== Anonymous methods ===
Anonymous methods are implemented inside other methods. They are not accessible outside of the method unless stored inside a delegate field. Anonymous methods can use the local variables of the method they're implemented in and the fields of the class they belong to.

Anonymous methods are especially useful when working with code that is supposed to be executed in a GUI thread, which is done in .NET by passing a method do the <code>Invoke</code> method (<code>Control.Invoke</code> in WinForms, <code>Dispatcher.Invoke</code> in WPF):
<source lang="delphi" highlight="1">
method Window1.PredictNearFuture;  //declared as async in the interface
begin
  // ... Calculate result here, store in variable "theFuture"
    Dispatcher.Invoke(DispatcherPriority.ApplicationIdle, method; begin
      theFutureTextBox.Text := theFuture;
    end);
end;</source>

Anonymous methods can have parameters, too:
<source lang="delphi" highlight="1">
method Window1.PredictNearFuture;  //declared as async in the interface
begin
  // ... Calculate result here, store in variable "theFuture"
    Dispatcher.Invoke(DispatcherPriority.ApplicationIdle, method(aFuture : String); begin
      theFutureTextBox.Text := aFuture ;
    end, theFuture);
end;</source>

Both source codes use anonymous delegates.

=== Property notification ===
Property notification is used mainly for data binding, when the [[Graphical user interface|GUI]] has to know when the value of a property changes. The .NET framework provides the interfaces <code>INotifyPropertyChanged</code> and <code>INotifyPropertyChanging</code> (in .NET 3.5) for this purpose. These interfaces define events which have to be fired when a property is changed / was changed.

Oxygene provides the <code>notify</code> modifier, which can be used on properties. If this modifier is used, the compiler will add the interfaces to the class, implement them and create code to raise the events when the property changes / was changed.

<source lang="delphi">
property Foo : String read fFoo write SetFoo; notify;
property Bar : String; notify 'Blubb'; //will notify that property "Blubb" was changed instead of "Bar"</source>

The modifier can be used on properties which have a setter method. The code to raise the events will then be added to this method during compile time.

== Code examples ==

=== Hello World ===
<source lang="delphi" highlight="1">
namespace HelloWorld;

interface

type
  HelloClass = class
  public
    class method Main;
  end;

implementation

class method HelloClass.Main;
begin
  writeLn('Hello World!');
end;

end.
</source>

=== Generic container ===
<source lang="delphi" highlight="1">
namespace GenericContainer;

interface

type
  TestApp = class
  public
    class method Main;
  end;

  Person = class
  public
    property FirstName: String;
    property LastName: String;     
  end;

implementation

uses
  System.Collections.Generic;

class method TestApp.Main;
begin
  var myList := new List<Person>; //type inference
  myList.Add(new Person(FirstName := 'John', LastName := 'Doe')); 
  myList.Add(new Person(FirstName := 'Jane', LastName := 'Doe'));
  myList.Add(new Person(FirstName := 'James', LastName := 'Doe')); 
  Console.WriteLine(myList[1].FirstName);  //No casting needed
  Console.ReadLine;       
end;

end.
</source>

=== Generic method ===
<source lang="delphi" highlight="1">
namespace GenericMethodTest;

interface

type
GenericMethodTest = static class
public
  class method Main;
private
  class method Swap<T>(var left, right : T);
  class method DoSwap<T>(left, right : T);
end;

implementation

class method GenericMethodTest.DoSwap<T>(left, right : T);
begin
  var a := left;
  var b := right;
  Console.WriteLine('Type: {0}', typeof(T));
  Console.WriteLine('-> a = {0}, b = {1}', a , b);
  Swap<T>(var a, var b);
  Console.WriteLine('-> a = {0}, b = {1}', a , b);
end;

class method GenericMethodTest.Main;
begin
  var a := 23;// type inference
  var b := 15;
  DoSwap<Integer>(a, b); // no downcasting to Object in this method.

  var aa := 'abc';// type inference
  var bb := 'def';
  DoSwap<String>(aa, bb); // no downcasting to Object in this method.

  DoSwap(1.1, 1.2); // type inference for generic parameters
  Console.ReadLine();
end;

class method GenericMethodTest.Swap<T>(var left, right : T);
begin
  var temp := left;
  left:= right;
  right := temp;
end;

end.
</source>

Program output:

 Type: System.Int32
 -> a = 23, b = 15
 -> a = 15, b = 23
 Type: System.String
 -> a = abc, b = def
 -> a = def, b = abc
 Type: System.Double
 -> a = 1,1, b = 1,2
 -> a = 1,2, b = 1,1

== Differences between Delphi and Oxygene ==
* {{code|unit}}: Replaced with the namespace keyword. Since Oxygene doesn't compile per-file but per-project, it does not depend on the name of the file. Instead the unit or namespace keyword is used to denote the default namespace that all types are defined in for that file
* {{code|procedure}} and {{code|function}}: {{code|method}} is the preferred keyword, though {{code|procedure}} and {{code|function}} still work.
* {{code|overload}}: In Oxygene all methods are overloaded by default, so no special keyword is needed for this
* {{code|.Create()}}: This constructor call has been replaced by the {{code|new}} keyword. It can still be enabled in the {{code|project options}} for legacy reasons
* {{code|string}}: Characters in strings are zero-based and read-only. Strings can have nil values, so testing against empty string is not always sufficient.

== Criticism ==
Some people{{who|date=November 2021}} would like to port their Win32 Delphi code to Oxygene without making major changes. This is not possible because while Oxygene looks like Delphi, there are enough changes so as to make it incompatible for a simple recompile. While the name gives it the appearance of another version of Delphi, that is not completely true.<ref>{{cite web|url=https://stackoverflow.com/questions/242584/will-you-use-delphi-prism|title=A Stack Overflow discussion where people remark that Oxygene is not Delphi Win32|access-date=2016-07-25|archive-url=https://web.archive.org/web/20121025132441/https://stackoverflow.com/questions/242584/will-you-use-delphi-prism|archive-date=2012-10-25|url-status=dead}}</ref>

On top of the language difference, the [[Software:Visual Component Library|Visual Component Library]] framework is not available in Oxygene.<ref>{{cite web|url=https://www.infoq.com/news/2009/09/Delphi-Prism-2010|title=Delphi Prism 2010 review where they state in the third paragraph that VCL.net is not available|access-date=2009-12-14|archive-date=2009-09-04|archive-url=https://web.archive.org/web/20090904215434/https://www.infoq.com/news/2009/09/Delphi-Prism-2010|url-status=live}}</ref> This makes porting even more difficult because classic Delphi code relies heavily on the VCL.

== See also ==
* [[C Sharp (programming language)|C#]]
* [[Object Pascal]]
* Embarcadero Delphi
* [[Software:Free Pascal|Free Pascal]]
* [[Eiffel (programming language)|Eiffel]]
* [[Java (programming language)|Java]]

== References ==
{{reflist|2}}

== External links ==

{{Pascal programming language family}}
{{Java (Sun)}}

[[Category:Class-based programming languages]]
[[Category:Object-oriented programming languages]]
[[Category:Pascal programming language family]]

{{Sourceattribution|Oxygene (programming language)}}