We also have blog posts on Enhanced Error Reporting and Spell Checking.

Language Features

The big new thing for the Oxygene 5 language is of course that it now supports Java, as discussed above. Beyond that, we've also added two pretty significant new language features in this release:

Duck Typing and Soft Interfaces

Duck Typing lets you treat objects as if they implement interfaces they do not actually implement, as long as they provide the necessary methods to qualify for that interface – according to the motto that if it looks and quacks like a duck, you can treat it as if it were a duck.

For example, imagine you're consuming a class that implements Dispose, but does not specify the IDisposable interface in its ancestry list. With Duck Typing, you can use that class inside a using statement:

using duck(MyObject) do …

Soft Interfaces complement Duck Typing by letting you define a custom interface that is compatible automatically with any type that qualifies for its members. Normally, when you define an interface, any class that you want to use with that interface has to explicitly implement the interface, by listing it in its ancestor list (and providing implementations for all its members, of course). But if you declare an interface with the extra soft keyword, any object that has the necessary members will automatically qualify!

For example, several simple types in the .NET framework provide an overloaded ToString() method that takes an optional string with formatting options. But since Int32 and Double share no common ancestor beyond System.Object, you cannot really write code that uses the types interchangeably to call ToString(format: String) on them. But what of you can define a soft interface like this:

type
  IStringFormatter = soft interface
    method ToString(format: String): string;
  end;

Now, both Int32 and Double (as well as many other types, such as Guid) conform to this IStringFormatter soft interface. You could declare a method such as:

method PrintPretty(value: IStringFormatter; format: string);

and pass all kinds of different types to it. The method would not care if it received an Int32 or Double – it would just know that it can call ToString(format: String) on the object it received.

Inline Interface Implementations

Inline Interface Implementations are a feature that has been added to the Oxygene language from Java – in part to make Oxgene a good citizen on the Java platform – but are available on .NET as well.

The Java platform does not use multicast events like .NET, but instead employs the more traditional delegate model, also found in Objective-C. Classes that fire events or have callbacks usually come with a companion delegate interface that defines any methods that the class wants to call back on.

Of course, implementing an interface in Oxygene is easy, but with the nature of events and callbacks, one might not always want to implement the delegate interface on the main object, and creating helper objects to provide delegates can become tedious and unwieldy as well, especially if you want to access state in your main object from the helper – which is common for event handlers.

With Oxygene 5, it is now possible to implement interfaces inline within a method body of your class, similar to how individual anonymous methods already work. Say we have a fictitious Button class that requires an IButtonDelegate interface for callbacks. We could provide this delegate as such:

begin
  var b := new Button;
  var lCaptionWhenClicked := 'You clicked me!';
  b.Events := new interface IButtonDelegate(OnClick := method(b2: Button) 
                                                       begin 
                                                         b2.Caption := lCaptionWhenClicked; 
                                                       end, 
                                            OnGetHoverHint := b2 -> 'Button '+b2.Caption);
end.

In essence, this declares a new anonymous class that provides implementation for the two OnClick and OngetHoverHint methods; just like with anonymous methods (or closures), from within the class, we have full access to the surrounding scope, including any local variables or our main object's members.

Read More

There are also two blog posts on Duck Typing and Inline Interfaces that go into more detail on these topics.