RFC: scope and borrowing

[Manu via Digitalmars-d]

On 22 September 2014 22:14, via Digitalmars-d <digitalmars-d at puremagic.com>
wrote:

> On Monday, 22 September 2014 at 11:45:39 UTC, Manu via Digitalmars-d wrote:
>
>> Application to scope will be identical to ref. A function that returns or
>> receives scope that is inserted into generic code must have that property
>> cascaded outwards appropriately. If typeof() or alias loses 'scope', then
>> it will all go tits-up.
>>
>
> For receiving it's not necessary, because whether or not the argument is
> scoped, the function can always borrow it. The lifetime of its parameter is
> narrower than what it gets passed.
>

It's particularly common in D to produce templates that wrap functions.
If the wrapper doesn't propagate scope outwards, then it can no longer be
called by a caller who borrowed arguments which are to be forwarded to the
function being called. Likewise for return values.

For return values, the situation is a bit different: They can of course not
> be assigned to non-scoped variables. But the solution for this simple: the
> generic code needs to use scope, too.


This is precisely the problem with ref...
Are you saying that ALL generic code needs to be 'scope' always? That's not
semantically correct.

A function that returns scope does so for a reason after all.


And the generic code can't know what it is. That knowledge must be encoded
in the type system.

This will work even if the return value of the called function turns out
> not to be scoped for this particular instantiation. And all this is an
> implementation of the generic code, it won't bleed outside, unless the
> generic code wants to return the scoped value. In this case, simply apply
> the same technique, just one lever higher.
>

I can't see the solution you're trying to ilustrate, can you demonstrate?
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.puremagic.com/pipermail/digitalmars-d/attachments/20140922/c24547ec/attachment.html>