On Saturday, 5 September 2015 at 19:59:03 UTC, bitwise wrote:
On Saturday, 5 September 2015 at 06:15:17 UTC, Jonathan M Davis
wrote:
On Friday, 4 September 2015 at 22:36:01 UTC, bitwise wrote:
On Friday, 4 September 2015 at 14:40:43 UTC, Jonathan M Davis
wrote:
[...]
Wow...this is surprising. At first glance, the streams seemed
to be fairly well done. What's the reason for them being
removed? and what is meant to be the replacement?
It's old (from D1) and does not follow the current best
practices or idioms. If we're going to have a stream solution,
it needs to be range-based. That being said, ranges in and of
themselves get pretty close to streams, and there simply
hasn't been a push to come up with a range-based stream
solution where the pieces that aren't already part of ranges
are taken care of. std.stream has been marked as scheduled for
deprecation for years, and no one has bothered to replace it.
It comes up periodically, but no one seems to care enough to
do anything about it. So, rather than leave it in that state,
we decided that it would be better off to just deprecate it
and then get rid of it rather than leave it in limbo with the
documentation saying that it's not up to our standards and
that we're going to get rid of it at some point. At some
point, someone may come up with a range-based stream solution
and get it into Phobos, but until then, we'll just use
straight up ranges, which come close enough for most cases.
std.stdio and std.mmfile make it quite possible to operate on
files with ranges in a manner similar to streams, and
std.stdio allows you to operate on stdin and stdout in a
similar manner (since they're std.stdio.Files).
That being said, std.stream is boost-licensed, and anyone is
free to copy it or fork it so long as the copyright notice is
left on it. So, anyone who wants to use std.stream in their
own code even after it's no longer in Phobos is free to do so.
It's just that the std.stream code is then going to have to be
part of their project rather than Phobos.
- Jonathan M Davis
Thanks for the explanation, but could you give an example of
how Stream would be rangified?
this was not addressed to me but here is how it should be done:
---
module runnable;
import std.stdio;
import std.stream;
import std.algorithm;
class RangifiedStream: MemoryStream
{
auto range()
{
return Range(this);
}
private struct Range
{
MemoryStream _str;
ulong _curr;
this(MemoryStream str)
{
_str = str;
}
void popFront()
{
_curr += 1;
}
@property ubyte front()
{
ubyte result;
_str.position = _curr;
_str.read(result);
_str.position = _str.position - 1;
return result;
}
@property bool empty()
{
return _curr == _str.size;
}
}
}
void main(string[] args)
{
import std.range;
assert( isInputRange!(RangifiedStream.Range));
RangifiedStream str = new RangifiedStream;
ubyte[] src = [0,1,2,3,4,5,6,7,8,9];
str.write(src);
str.range.each!(a => a.writeln);
}
---
The range has a reference to a stream. The range uses its own
position and this is important since several ranges may co-exist
at the same time. Here you just have a byte InputRange but it
works...
For FileStream the performances will be terrible (bad), because
the position is hold by a a structure specific to the OS...
I think I'll add this to my iz streams classes.
