View source for Calypso/LanguageAdditions

In order to reduce the verbosity of D code (any D code, not just code making use of C++ libraries although they're the most affected) some experimental language features were added to D.

== scope ref ==

A feature recurringly requested, its absence considered by many as producing terrible looking code, yet despite pull requests never made it into D:

  http://forum.dlang.org/post/mailman.3720.1453131378.22025.digitalmars-d@puremagic.com

Not being able to pass rvalues to <strong><code>ref</code></strong> parameters of non-template functions forces to manually declare temporaries:

<syntaxhighlight lang="D">
void foo(ref SomeTy arg);

// foo(SomeTy(xyz)); // doesn't compile, so rewritten to:

auto temp = SomeTy(xyz);
foo(temp);
</syntaxhighlight>

A workaround is to write template functions with <code><strong>auto ref</strong></code> parameters, but this multiplies the number of symbols, and why shouldn't <code><strong>const ref</strong></code> or <code><strong>immutable ref</strong></code> be able to take rvalues in the first place, the C++ way?

Anyway mapped C++ functions by Calypso do not have the luxury of being rewritten as templates, and <code>const Type&</code> is omnipresent.

So because this wasn't bearable anymore, Calypso went ahead. Whether the reference escapes or not isn't checked, so the current implementation is a hack reaping the code beautification benefits while disregarding all safety and even correctness (temporaries should be used at least for literals):

https://github.com/Syniurge/Calypso/commit/652780400cac85aa75670eba263c93e48bf2432f
https://github.com/Syniurge/Calypso/commit/af60ca29add17df0f45cd722c39d756668d453cf

== Explicitly implicit constructor calls for functions arguments ==

In C++ constructors may be implicitly called by default unless marked <code>explicit</code>. This means that if a passed argument type ArgTy doesn't match any of the function overloads' parameter type ParamTy and if ParamTy is a class or struct, the C++ compiler looks for a constructor from ParamTy that takes an ArgTy argument and implicitly replace <code>f(original_arg)</code> by <code>f(ParamTy(original_arg))</code>.

D doesn't have implicit constructor calls. It may prevent some surprises, but a drawback is a lot more verbose code for instance whenever a custom string or reference class is needed:

<syntaxhighlight lang="D">
class CustomStr
{
  (...)
  CustomStr(string s) {...}
}

void Foo(CustomStr arg1, CustomStr arg2);

void Bar() {
  Foo(CustomStr("some string"), CustomStr("another string"));
}
</syntaxhighlight>

This is a very common occurrence in C++ libraries. Using Qt means plastering the code with <code>QSomeFunc(QString("lorem ipsum"))</code>, using OpenCV means <code>InputArray</code> or <code>OutputArray</code> everywhere, etc.

Implicit constructor calls have been little discussed as far as I know, but desired from times to times:

  http://forum.dlang.org/post/ltdchmnokbgyjctiqxru@forum.dlang.org

The <strong>@implicit</strong> attribute was added to DMD in order to enable implicit constructor calls, and in Calypso is applied to all C++ non-<b>explicit</b> constructors:

https://github.com/Syniurge/Calypso/commit/999bd81cd094584a1db2357230888bf7d96e7d09
https://github.com/Syniurge/Calypso/commit/66df399a0d0bf5f3ccd8c96db354635eef86480b
https://github.com/Syniurge/Calypso/commit/4e080f5cd1fa636a98d50d35a2632abcdcbe75cc
https://github.com/Syniurge/Calypso/commit/471fad6a1dba98c752d1dee1f81e836d16a89320

[[Category:Experimental compilers]]