www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - observation: D getting a bit complex

reply "Spacen Jasset" <spacen razemail.com> writes:
The following reminds me of the good old C++ template errors the 
C++ compiler spits out.

Whilst D has fixed that problem, some things have gotten more 
complex. I just wanted to find a replacement for D1 path join, 
and found this, but it doesn't seem very easy to wade though this 
stuff.


immutable(ElementEncodingType!(ElementType!Range))[] 
buildPath(Range)(Range segments) if (isInputRange!Range && 
isSomeString!(ElementType!Range));
pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][] 
paths...) if (isSomeChar!C);

http://dlang.org/phobos/std_path.html

It would take me a lot of time to appeciate what that all means, 
although I can imagine what it is for.

...just and observation. The complexity is building.
Aug 29 2015
next sibling parent Sergey Korshunoff via Digitalmars-d-learn writes:
Hi!
I completely agree. D1 is much better :-) I removed a threading
support from my variant  because program don't start if OS don't have
a POSIX threading (LInux 2.4.37 for example). A garbage colllector can
be disabled (as I understand). May be a compiler support (warnings) is
needed if gc will be used (needed) in the code

With such changes D1 can be used for Linux kernel modules. But I don't
done this yet. I nice stuff: libc written in D (a small part of the
uCLibc, not finished)

PS: trying to understand a D backend I removed all stuff related to
the C++ and win32
PPS: what is the rigth way to connect a backed to the frontend? I

compiler with custom asm generator (GDC and LDC are not studied)


2015-08-30 5:42 GMT+03:00, Spacen Jasset via Digitalmars-d-learn
<digitalmars-d-learn puremagic.com>:

 The following reminds me of the good old C++ template errors the
 C++ compiler spits out.

 Whilst D has fixed that problem, some things have gotten more
 complex. I just wanted to find a replacement for D1 path join,
 and found this, but it doesn't seem very easy to wade though this
 stuff.


 immutable(ElementEncodingType!(ElementType!Range))[]
 buildPath(Range)(Range segments) if (isInputRange!Range &&
 isSomeString!(ElementType!Range));
 pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][]
 paths...) if (isSomeChar!C);

 http://dlang.org/phobos/std_path.html

 It would take me a lot of time to appeciate what that all means,
 although I can imagine what it is for.

 ...just and observation. The complexity is building.
Aug 29 2015
prev sibling next sibling parent "Jack Stouffer" <jack jackstouffer.com> writes:
On Sunday, 30 August 2015 at 02:42:30 UTC, Spacen Jasset wrote:

 immutable(ElementEncodingType!(ElementType!Range))[] 
 buildPath(Range)(Range segments) if (isInputRange!Range && 
 isSomeString!(ElementType!Range));
 pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][] 
 paths...) if (isSomeChar!C);


I understand how you feel. When I was learning D, the docs where 
almost impenetrable because of this. But when I got into some of 
the more advanced features of D, I found these explicit function 
signatures invaluable. This essentially tells you that the 
function takes either a range of strings, or it can take 
indefinite number of strings as different arguments.

Also, examples underneath the function signature help new comers 
understand how to call the function without having to parse it.
Aug 29 2015
prev sibling next sibling parent reply "BBasile" <bb.temp gmx.com> writes:
On Sunday, 30 August 2015 at 02:42:30 UTC, Spacen Jasset wrote:

 immutable(ElementEncodingType!(ElementType!Range))[] 
 buildPath(Range)(Range segments) if (isInputRange!Range && 
 isSomeString!(ElementType!Range));
 pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][] 
 paths...) if (isSomeChar!C);


this is stodgy, particularly in a console with line wrapping at 
80 chars.
Aug 30 2015
next sibling parent reply "Dominikus Dittes Scherkl" writes:
On Sunday, 30 August 2015 at 07:36:55 UTC, BBasile wrote:

 On Sunday, 30 August 2015 at 02:42:30 UTC, Spacen Jasset wrote:

 immutable(ElementEncodingType!(ElementType!Range))[] 
 buildPath(Range)(Range segments) if (isInputRange!Range && 
 isSomeString!(ElementType!Range));
 pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][] 
 paths...) if (isSomeChar!C);


 this is stodgy, particularly in a console with line wrapping at 
 80 chars.


Could have been written as

auto buildPath(Range)(Range segments)
if (isInputRange!Range && isSomeString!(ElementType!Range));

but having an explicit return type is super valuable information. 
But the opportunity to omit it makes implementing a first working 
version so fast that it is pure joy.

And the constraints you need not read - unless you want to 
understand why your call to the function failed. C++ is just 
lacking without them. Having them avoids that you always have to 
handle ridiculous input within your functions and allows to 
concentrate on meaningful code.
Aug 30 2015
parent "cym13" <cpicard openmailbox.org> writes:
On Sunday, 30 August 2015 at 09:55:02 UTC, Dominikus Dittes 
Scherkl wrote:

 And the constraints you need not read - unless you want to 
 understand why your call to the function failed. C++ is just 
 lacking without them. Having them avoids that you always have 
 to handle ridiculous input within your functions and allows to 
 concentrate on meaningful code.


Maybe we should color thoses things, having syntax highlighting 
for template and functions signatures would be great.
Aug 30 2015
prev sibling next sibling parent reply "Spacen Jasset" <spacen razemail.com> writes:
On Sunday, 30 August 2015 at 07:36:55 UTC, BBasile wrote:

 On Sunday, 30 August 2015 at 02:42:30 UTC, Spacen Jasset wrote:

 immutable(ElementEncodingType!(ElementType!Range))[] 
 buildPath(Range)(Range segments) if (isInputRange!Range && 
 isSomeString!(ElementType!Range));
 pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][] 
 paths...) if (isSomeChar!C);


 this is stodgy, particularly in a console with line wrapping at 
 80 chars.



To be fair is was the docs page I was reading not a compiler 
diagnostic, but I did get something a bit shorter from the 
compiler once.

It's slighty hard to see that you can give that function a 
string, and that it can return a string like thing -- although on 
that score too I've found I have to use char[] in some places 
instead of string which is to do with immutability, that I've not 
quite worked that out yet either -- It's just a feeling I have 
when looking at this now that it is quite complex.

I only mention this as it was something that I think other people 
may notice too, when starting out, or coming back to D.

Maybe I've just been doing too much python recently.
Aug 30 2015
parent "BBasile" <bb.temp gmx.com> writes:
On Sunday, 30 August 2015 at 10:42:24 UTC, Spacen Jasset wrote:

 On Sunday, 30 August 2015 at 07:36:55 UTC, BBasile wrote:

 On Sunday, 30 August 2015 at 02:42:30 UTC, Spacen Jasset wrote:

 immutable(ElementEncodingType!(ElementType!Range))[] 
 buildPath(Range)(Range segments) if (isInputRange!Range && 
 isSomeString!(ElementType!Range));
 pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][] 
 paths...) if (isSomeChar!C);


 this is stodgy, particularly in a console with line wrapping 
 at 80 chars.



 To be fair it was the docs page I was reading not a compiler 
 diagnostic, but I did get something a bit shorter from the 
 compiler once.


Oh i see. Then i don't agree. Doc is very nice. The problem is 
that you have to know std.traits and std.range to understand the 
constraints. It's not always obvious but i'd say it's about 30 or 
40 functions.
Aug 30 2015
prev sibling parent "H. S. Teoh via Digitalmars-d-learn" <digitalmars-d-learn puremagic.com> writes:
On Sun, Aug 30, 2015 at 07:36:53AM +0000, BBasile via Digitalmars-d-learn wrote:

 On Sunday, 30 August 2015 at 02:42:30 UTC, Spacen Jasset wrote:

immutable(ElementEncodingType!(ElementType!Range))[]
buildPath(Range)(Range segments) if (isInputRange!Range &&
isSomeString!(ElementType!Range));
pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][] paths...) if
(isSomeChar!C);


 
 this is stodgy, particularly in a console with line wrapping at 80
 chars.


https://issues.dlang.org/show_bug.cgi?id=13676


T

-- 
People who are more than casually interested in computers should have at least
some idea of what the underlying hardware is like. Otherwise the programs they
write will be pretty weird. -- D. Knuth
Aug 30 2015
prev sibling next sibling parent "bachmeier" <no spam.net> writes:
On Sunday, 30 August 2015 at 02:42:30 UTC, Spacen Jasset wrote:

 The following reminds me of the good old C++ template errors 
 the C++ compiler spits out.

 Whilst D has fixed that problem, some things have gotten more 
 complex. I just wanted to find a replacement for D1 path join, 
 and found this, but it doesn't seem very easy to wade though 
 this stuff.


 immutable(ElementEncodingType!(ElementType!Range))[] 
 buildPath(Range)(Range segments) if (isInputRange!Range && 
 isSomeString!(ElementType!Range));
 pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][] 
 paths...) if (isSomeChar!C);

 http://dlang.org/phobos/std_path.html

 It would take me a lot of time to appeciate what that all 
 means, although I can imagine what it is for.

 ...just and observation. The complexity is building.


With C++ I rarely have trouble finding a good explanation, it's 
just a really complex language that doesn't get easier when you 
use it. For D, the documentation is a work in progress, 
amplifying the learning curve for the things that make life 
easier for experienced programmers.

The official documentation is going to have to take a better 
approach when dealing with ranges and generic programming because 
the current approach doesn't work at all.
Aug 30 2015
prev sibling parent anonymous <anonymous example.com> writes:
On Sunday 30 August 2015 04:42, Spacen Jasset wrote:


 immutable(ElementEncodingType!(ElementType!Range))[]
 buildPath(Range)(Range segments) if (isInputRange!Range &&
 isSomeString!(ElementType!Range));
 pure nothrow  safe immutable(C)[] buildPath(C)(const(C)[][]
 paths...) if (isSomeChar!C);
 
 http://dlang.org/phobos/std_path.html


It's less horrible in the /library/ docs:

----
immutable(ElementEncodingType!(ElementType!Range))[] buildPath(Range)(
  Range segments
)
if (isInputRange!Range && isSomeString!(ElementType!Range));

immutable(C)[] buildPath(C)(
  const(C)[][] paths
) pure nothrow  safe
if (isSomeChar!C);
----

http://dlang.org/library/std/path/build_path.html

The /library/ docs are supposed to replace the current /phobos/ ones, but I 
don't know what's the latest on that.
Aug 30 2015