www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - When should I use SortedRange.release?

reply Bastiaan Veelo <Bastiaan Veelo.net> writes:
For reference, `SortedRange.release` is 
[documented](https://dlang.org/phobos/std_range.html#.SortedRange) as such:

"Releases the controlled range and returns it."

Wow thanks! I love functions that are named exactly as what they 
do ;-) Seriously though, I still don't know what it is that it 
does, and why and when it should be done, and when not.

What happens when a range is released?
What happens if a range is not released?
What happens if a range is released more than once?

And what does "controlled" imply here? In what way has 
`SortedRange` control over the underlaying data? What can I do 
and what can't I do to the underlying data as long as 
`SortedRange` has control?

My failure to understand this function makes me fear I don't 
understand `SortedRange` at all, and thereby don't understand how 
to use `algorithm.sorting` properly.

Thanks!

-- Bastiaan.
Apr 23
next sibling parent reply Paul Backus <snarwin gmail.com> writes:
On Friday, 23 April 2021 at 17:35:13 UTC, Bastiaan Veelo wrote:
 What happens when a range is released?
 What happens if a range is not released?
 What happens if a range is released more than once?

 And what does "controlled" imply here? In what way has 
 `SortedRange` control over the underlaying data? What can I do 
 and what can't I do to the underlying data as long as 
 `SortedRange` has control?
I had to look at the source to figure this out. Fortunately, the source is pretty simple: https://phobos.dpldocs.info/source/std.range.d.html#L10833 Turns out, it just calls `core.lifetime.move`. So I guess when the docs say "control", what they are really talking about is ownership. Practically speaking, this means that in generic code, we should avoid using a `SortedRange` after calling `release`, since we do not know whether the range is owning or non-owning w.r.t. the underlying data.
Apr 23
parent Bastiaan Veelo <Bastiaan Veelo.net> writes:
On Friday, 23 April 2021 at 18:35:25 UTC, Paul Backus wrote:
 On Friday, 23 April 2021 at 17:35:13 UTC, Bastiaan Veelo wrote:
 What happens when a range is released?
 What happens if a range is not released?
 What happens if a range is released more than once?

 And what does "controlled" imply here? In what way has 
 `SortedRange` control over the underlaying data? What can I do 
 and what can't I do to the underlying data as long as 
 `SortedRange` has control?
I had to look at the source to figure this out. Fortunately, the source is pretty simple: https://phobos.dpldocs.info/source/std.range.d.html#L10833 Turns out, it just calls `core.lifetime.move`. So I guess when the docs say "control", what they are really talking about is ownership. Practically speaking, this means that in generic code, we should avoid using a `SortedRange` after calling `release`, since we do not know whether the range is owning or non-owning w.r.t. the underlying data.
Thanks. There is no word in the documentation about when `SortedRange` would or would not be owning data, though, and hence when `release` would be appropriate to call. To me `release` seems to be calling `std.algorithm.mutation.move` , but it is probably very similar to `core.lifetime.move`. In case the underlying data is a slice, I think we end up at https://phobos.dpldocs.info/source/std.algorithm.mutation.d.html#L1459, which I can't see accomplishes anything in [this example](https://dlang.org/phobos/std_algorithm_sorting.html#.sort) (except returning the slice that went in): ```d int[] array = [ 1, 2, 3, 4 ]; // sort in descending order array.sort!("a > b"); writeln(array); // [4, 3, 2, 1] // sort in ascending order array.sort(); writeln(array); // [1, 2, 3, 4] // sort with reusable comparator and chain alias myComp = (x, y) => x > y; writeln(array.sort!(myComp).release); // [4, 3, 2, 1] ``` -- Bastiaan.
Apr 23
prev sibling parent reply Steven Schveighoffer <schveiguy gmail.com> writes:
On 4/23/21 1:35 PM, Bastiaan Veelo wrote:
 For reference, `SortedRange.release` is 
 [documented](https://dlang.org/phobos/std_range.html#.SortedRange) as such:
 
 "Releases the controlled range and returns it."
 
 Wow thanks! I love functions that are named exactly as what they do ;-) 
 Seriously though, I still don't know what it is that it does, and why 
 and when it should be done, and when not.
 
 What happens when a range is released?
 What happens if a range is not released?
 What happens if a range is released more than once?
 
 And what does "controlled" imply here? In what way has `SortedRange` 
 control over the underlaying data? What can I do and what can't I do to 
 the underlying data as long as `SortedRange` has control?
 
 My failure to understand this function makes me fear I don't understand 
 `SortedRange` at all, and thereby don't understand how to use 
 `algorithm.sorting` properly.
 
`SortedRange` itself is kind of a kludge of "policy" that isn't fit for function. I use release to get the original data type out (via r.save.release), but that's about it. See my rant about it [here](https://forum.dlang.org/post/r7ia94$19uo$1 digitalmars.com) -Steve
Apr 23
parent Bastiaan Veelo <Bastiaan Veelo.net> writes:
On Friday, 23 April 2021 at 21:34:39 UTC, Steven Schveighoffer 
wrote:
 `SortedRange` itself is kind of a kludge of "policy" that isn't 
 fit for function.

 I use release to get the original data type out (via 
 r.save.release), but that's about it.

 See my rant about it 
 [here](https://forum.dlang.org/post/r7ia94$19uo$1 digitalmars.com)

 -Steve
Understood, thanks. --Bastiaan.
Apr 23