• Per =?UTF-8?B?Tm9yZGzDtnc=?= (14/14) Mar 22 2021 Am I the only one being annoyed by the fact that
• Per =?UTF-8?B?Tm9yZGzDtnc=?= (10/11) Mar 22 2021 To clarify, for instance, given
• ag0aep6g (12/18) Mar 22 2021 Works for me:
• Steven Schveighoffer (13/34) Mar 22 2021 He didn't specify clearly on the original post. Yours works because
• ag0aep6g (7/17) Mar 22 2021 Ah, right. Purity was a red herring then. If you put a `const(char)[]`
• Per =?UTF-8?B?Tm9yZGzDtnc=?= (27/29) Mar 23 2021 that calls the template overload
• Per =?UTF-8?B?Tm9yZGzDtnc=?= (4/9) Mar 23 2021 How do we want this to work with and without the presence of

Per =?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:

Am I the only one being annoyed by the fact that

     chainPath(...).array

doesn't implicit convert to string despite the array returned 
from .array is allocated by the GC.

Yes, I know that I should do

     chainPath(...).array.assumeUnique

but the uniqueness of .array (and in turn implicit conversion to 
immutable) should be inferred by the compiler.

Inference could happen in the same compiler pass that checks 
(will infer) scope qualifiers.

Are there plans for making this happen?

Is having a  unique qualifier motivated for the sake of compiler 
performance to avoid the for need transitive inference across 
function calls?

Per =?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:

On Monday, 22 March 2021 at 20:38:36 UTC, Per Nordlöw wrote:
     chainPath(...).array

To clarify, for instance, given

       string s;
       const(char)[] c;

all the calls

       chainPath(s, s).array
       chainPath(c, c).array
       chainPath(s, c).array
       chainPath(c, s).array

return a value of type const(char)[].

ag0aep6g <anonymous example.com> writes:

On 22.03.21 21:38, Per Nordlöw wrote:
 Am I the only one being annoyed by the fact that
 
      chainPath(...).array
 
 doesn't implicit convert to string despite the array returned from 
 .array is allocated by the GC.

Works for me:

----
import std.array: array;
import std.path: chainPath;
void main()
{
     string chained = chainPath("foo", "bar").array;
}
----

Uniqueness is being inferred based on purity. If it doesn't work for 
you, then you're probably doing something impure.

Steven Schveighoffer <schveiguy gmail.com> writes:

On 3/22/21 5:58 PM, ag0aep6g wrote:
 On 22.03.21 21:38, Per Nordlöw wrote:
 Am I the only one being annoyed by the fact that

      chainPath(...).array

 doesn't implicit convert to string despite the array returned from 
 .array is allocated by the GC.

 
 Works for me:
 
 ----
 import std.array: array;
 import std.path: chainPath;
 void main()
 {
      string chained = chainPath("foo", "bar").array;
 }
 ----
 
 Uniqueness is being inferred based on purity. If it doesn't work for 
 you, then you're probably doing something impure.

He didn't specify clearly on the original post. Yours works because 
everything is a string.

Try

const(char)[] x = "foo";
string chained = chainPath(x, "bar").array;

Error: cannot implicitly convert expression array(chainPath(x, "bar")) 
of type const(char)[] to string

And the answer is complex. You can't accept a const range, because they 
don't work. The only way to have purity infer uniqueness is to accept 
paramters that the result could not have come from. Usually this means 
accepting const and returning mutable.

-Steve

ag0aep6g <anonymous example.com> writes:

On 23.03.21 02:07, Steven Schveighoffer wrote:
 const(char)[] x = "foo";
 string chained = chainPath(x, "bar").array;
 
 Error: cannot implicitly convert expression array(chainPath(x, "bar")) 
 of type const(char)[] to string
 
 And the answer is complex. You can't accept a const range, because they 
 don't work. The only way to have purity infer uniqueness is to accept 
 paramters that the result could not have come from. Usually this means 
 accepting const and returning mutable.

Ah, right. Purity was a red herring then. If you put a `const(char)[]` 
in and you get a `const(char)[]` out, then the compiler must assume that 
it might be the same one.

We could possibly change `.array` to return a `char[]`. Uniqueness would 
still fail when you pass a `char[]` in, but that could be worked around 
by adding a const temporary.

Per =?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:

On Tuesday, 23 March 2021 at 01:07:15 UTC, Steven Schveighoffer 
wrote:
 const(char)[] x = "foo";
 string chained = chainPath(x, "bar").array;

that calls the template overload

ForeachType!Range[] array(Range)(Range r)
if (isIterable!Range && !isAutodecodableString!Range && 
!isInfinite!Range)

should be able to implicitly convert to string because the .array 
expression is inferred `pure`. Or is the compiler pessimistically 
assuming that the slice returned from the .array call may reside 
from a reference reachable from the range parameter `r`?

See for instance

 safe pure unittest
{
     import std.path : chainPath;
     import std.array : array;
     const(char)[] x1 = "foo";
     const string x2 = "bar";
     auto y1 = chainPath(x1, x2).array;
     pragma(msg, __FILE__, "(", __LINE__, ",1): Debug: ", 
typeof(y1));
     auto y2 = chainPath(x2, x1).array;
     pragma(msg, __FILE__, "(", __LINE__, ",1): Debug: ", 
typeof(y2));
}

printing

/home/per/f.d(8,1): Debug: const(char)[]
/home/per/f.d(10,1): Debug: const(char)[]

Per =?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:

On Tuesday, 23 March 2021 at 01:07:15 UTC, Steven Schveighoffer 
wrote:
 And the answer is complex. You can't accept a const range, 
 because they don't work. The only way to have purity infer 
 uniqueness is to accept paramters that the result could not 
 have come from. Usually this means accepting const and 
 returning mutable.

How do we want this to work with and without the presence of 
`return` qualified parameters?