www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Exquisite code samples

reply Gor Gyolchanyan <gor.f.gyolchanyan gmail.com> writes:
I've put together a code sample, which could demonstrate the awesome power
of D when it comes to getting good results very quickly and safely. Perhaps
it could end up on display for newcomers:

import std.traits;

/// Returns the t-th point on the bezier curve, defined by non-empty set p
of d-dimensional points, where t : [0, 1] and d > 1.
real[d] bezier(size_t d, Number)(Number[d][] p, Number t)
    if(d > 1 && isFloatingPoint!Number)
in
{
    assert(p.length > 0);
    assert(t >= 0.0L && t <= 1.0L);
}
body
{
    return p.length > 1 ? (1 - t) * p[0..$-1].bezier(t) + t *
p[1..$].bezier(t) : p[0];
}

/// Returns k unidistant points on the bezier curve, defined by non-empty
set p of d-dimensional points, where k > 0 and d > 1.
real[d][] bezier(size_t d, Number)(Number[d][] p, size_t k)
    if(d > 1 && isFloatingPoint!Number)
in
{
    assert(p.length > 0);
    assert(k > 0);
}
body
{
    Number[d][] result = new Number[d][k];
    foreach(i; 0..k)
        result[k] = p.bezier(i * (1.0L / k));
    return result;
}

-- 
Bye,
Gor Gyolchanyan.
Jul 09 2012
parent reply "Paulo Pinto" <pjmlp progtools.org> writes:
On Monday, 9 July 2012 at 11:16:45 UTC, Gor Gyolchanyan wrote:

 I've put together a code sample, which could demonstrate the 
 awesome power
 of D when it comes to getting good results very quickly and 
 safely. Perhaps
 it could end up on display for newcomers:

 import std.traits;

 /// Returns the t-th point on the bezier curve, defined by 
 non-empty set p
 of d-dimensional points, where t : [0, 1] and d > 1.
 real[d] bezier(size_t d, Number)(Number[d][] p, Number t)
     if(d > 1 && isFloatingPoint!Number)
 in
 {
     assert(p.length > 0);
     assert(t >= 0.0L && t <= 1.0L);
 }
 body
 {
     return p.length > 1 ? (1 - t) * p[0..$-1].bezier(t) + t *
 p[1..$].bezier(t) : p[0];
 }

 /// Returns k unidistant points on the bezier curve, defined by 
 non-empty
 set p of d-dimensional points, where k > 0 and d > 1.
 real[d][] bezier(size_t d, Number)(Number[d][] p, size_t k)
     if(d > 1 && isFloatingPoint!Number)
 in
 {
     assert(p.length > 0);
     assert(k > 0);
 }
 body
 {
     Number[d][] result = new Number[d][k];
     foreach(i; 0..k)
         result[k] = p.bezier(i * (1.0L / k));
     return result;
 }


I would not show this to newcomers, as they would probably go 
running for Go.

This type of code is quite nice and the reason why I think I am 
better served with D than Go, but newcomers without strong 
generic programming background in other languages might get 
scared.

--
Paulo
Jul 09 2012
next sibling parent reply Gor Gyolchanyan <gor.f.gyolchanyan gmail.com> writes:
On Mon, Jul 9, 2012 at 3:30 PM, Paulo Pinto <pjmlp progtools.org> wrote:


 On Monday, 9 July 2012 at 11:16:45 UTC, Gor Gyolchanyan wrote:


 I've put together a code sample, which could demonstrate the awesome power
 of D when it comes to getting good results very quickly and safely.
 Perhaps
 it could end up on display for newcomers:

 import std.traits;

 /// Returns the t-th point on the bezier curve, defined by non-empty set p
 of d-dimensional points, where t : [0, 1] and d > 1.
 real[d] bezier(size_t d, Number)(Number[d][] p, Number t)
     if(d > 1 && isFloatingPoint!Number)
 in
 {
     assert(p.length > 0);
     assert(t >= 0.0L && t <= 1.0L);
 }
 body
 {
     return p.length > 1 ? (1 - t) * p[0..$-1].bezier(t) + t *
 p[1..$].bezier(t) : p[0];
 }

 /// Returns k unidistant points on the bezier curve, defined by non-empty
 set p of d-dimensional points, where k > 0 and d > 1.
 real[d][] bezier(size_t d, Number)(Number[d][] p, size_t k)
     if(d > 1 && isFloatingPoint!Number)
 in
 {
     assert(p.length > 0);
     assert(k > 0);
 }
 body
 {
     Number[d][] result = new Number[d][k];
     foreach(i; 0..k)
         result[k] = p.bezier(i * (1.0L / k));
     return result;
 }


 I would not show this to newcomers, as they would probably go running for
 Go.

 This type of code is quite nice and the reason why I think I am better
 served with D than Go, but newcomers without strong generic programming
 background in other languages might get scared.

 --
 Paulo


You're right. This is a bit advanced code sample, which uses templates,
template constraints, contract programming among syntax advantages of D.

-- 
Bye,
Gor Gyolchanyan.
Jul 09 2012
next sibling parent reply "renoX" <renozyx gmail.com> writes:
On Monday, 9 July 2012 at 11:40:37 UTC, Gor Gyolchanyan wrote:
[cut]

 You're right. This is a bit advanced code sample, which uses 
 templates,template constraints, contract programming among 
 syntax advantages of D.


Hum it show the power of D sure, but IMHO it also show its syntax 
deficiencies..

For me this "real[d] bezier(size_t d, Number)(Number[d][] p, 
Number t)
    if(d > 1 && isFloatingPoint!Number)" is difficult to read, and 
a better syntax would be:
real[d] bezier!(size_t d && d > 1, Number && 
isFloatingPoint!Number)(Number[d][] p, Number t)

The template parameter would be indicated in a !() (as in a 
call), and the template constraints inside the template 
parameter: this way the template parameters are clearly indicated 
and separated from the function parameter.

renoX
Jul 10 2012
parent reply Don Clugston <dac nospam.com> writes:
On 10/07/12 09:49, renoX wrote:

 On Monday, 9 July 2012 at 11:40:37 UTC, Gor Gyolchanyan wrote:
 [cut]

 You're right. This is a bit advanced code sample, which uses
 templates,template constraints, contract programming among syntax
 advantages of D.


 Hum it show the power of D sure, but IMHO it also show its syntax
 deficiencies..

 For me this "real[d] bezier(size_t d, Number)(Number[d][] p, Number t)
 if(d > 1 && isFloatingPoint!Number)" is difficult to read, and a better
 syntax would be:
 real[d] bezier!(size_t d && d > 1, Number &&
 isFloatingPoint!Number)(Number[d][] p, Number t)

 The template parameter would be indicated in a !() (as in a call), and
 the template constraints inside the template parameter: this way the
 template parameters are clearly indicated and separated from the
 function parameter.

 renoX


Well it used to work vaguely in that way, but it gets very ugly once you 
leave the simplest cases.  Even that one you've listed is hard for me to 
read.
And the idea that constraints apply to individual parameters is wrong. 
If you have a constraint that depends on two template parameters, where 
do you put it?

int bezier (int A, int B)(int t) if ( A + B == 10 )
Jul 10 2012
parent "renoX" <renozyx gmail.com> writes:
On Tuesday, 10 July 2012 at 09:24:42 UTC, Don Clugston wrote:

 On 10/07/12 09:49, renoX wrote:

 On Monday, 9 July 2012 at 11:40:37 UTC, Gor Gyolchanyan wrote:
 [cut]

 You're right. This is a bit advanced code sample, which uses
 templates,template constraints, contract programming among 
 syntax
 advantages of D.


 Hum it show the power of D sure, but IMHO it also show its 
 syntax
 deficiencies..

 For me this "real[d] bezier(size_t d, Number)(Number[d][] p, 
 Number t)
 if(d > 1 && isFloatingPoint!Number)" is difficult to read, and 
 a better
 syntax would be:
 real[d] bezier!(size_t d && d > 1, Number &&
 isFloatingPoint!Number)(Number[d][] p, Number t)

 The template parameter would be indicated in a !() (as in a 
 call), and
 the template constraints inside the template parameter: this 
 way the
 template parameters are clearly indicated and separated from 
 the
 function parameter.

 renoX


 Well it used to work vaguely in that way, but it gets very ugly 
 once you leave the simplest cases.  Even that one you've listed 
 is hard for me to read.



IMHO, the "normal" way is even harder to read..



 And the idea that constraints apply to individual parameters is 
 wrong. If you have a constraint that depends on two template 
 parameters, where do you put it?

 int bezier (int A, int B)(int t) if ( A + B == 10 )



How about:
int bezier!(int A, int B; A + B == 10)(int t) ?

I think that grouping together template parameters and 
constraints helps the readability YMMV.

BR,
renoX

PS: Sorry for the multiple posting, the posting didn't seem to 
work so I retried..
Jul 17 2012
prev sibling next sibling parent "renoX" <renozyx gmail.com> writes:
On Monday, 9 July 2012 at 11:40:37 UTC, Gor Gyolchanyan wrote:
[cut]

 You're right. This is a bit advanced code sample, which uses 
 templates,template constraints, contract programming among 
 syntax advantages of D.


Hum it show the power of D sure, but IMHO it also show its syntax 
deficiencies..

For me this "real[d] bezier(size_t d, Number)(Number[d][] p, 
Number t)
    if(d > 1 && isFloatingPoint!Number)" is difficult to read, and 
a better syntax would be:
real[d] bezier!(size_t d && d > 1, Number && 
isFloatingPoint!Number)(Number[d][] p, Number t)
or maybe:
real[d] bezier!(size_t d, Number; d > 1 && 
isFloatingPoint!Number)(Number[d][] p, Number t)

The template parameter would be indicated in a !() (as in a 
call), and the template constraints inside the template 
parameter: this way the template parameters are clearly indicated 
and separated from the function parameter.

renoX
Jul 10 2012
prev sibling next sibling parent "renoX" <renozyx gmail.com> writes:
On Monday, 9 July 2012 at 11:40:37 UTC, Gor Gyolchanyan wrote:
[cut]

 You're right. This is a bit advanced code sample, which uses 
 templates, template constraints, contract programming among 
 syntax advantages of D.


Hum it shows the power of D sure, but IMHO it also shows its 
syntax deficiencies..

For me this "real[d] bezier(size_t d, Number)(Number[d][] p, 
Number t)
    if(d > 1 && isFloatingPoint!Number)" is difficult to read, and 
a better syntax would be for example:
real[d] bezier!(size_t d && d > 1, Number && 
isFloatingPoint!Number)(Number[d][] p, Number t)
or:
real[d] bezier!(size_t d, Number; d > 1 && 
isFloatingPoint!Number)(Number[d][] p, Number t)

The template parameter would be indicated in a !() (as in a 
call), and the template constraints inside the template parameter

renoX
Jul 10 2012
prev sibling parent "SomeDude" <lovelydear mailmetrash.com> writes:
On Monday, 9 July 2012 at 11:40:37 UTC, Gor Gyolchanyan wrote:

 On Mon, Jul 9, 2012 at 3:30 PM, Paulo Pinto 
 <pjmlp progtools.org> wrote:


 On Monday, 9 July 2012 at 11:16:45 UTC, Gor Gyolchanyan wrote:


 I've put together a code sample, which could demonstrate the 
 awesome power
 of D when it comes to getting good results very quickly and 
 safely.
 Perhaps
 it could end up on display for newcomers:

 import std.traits;

 /// Returns the t-th point on the bezier curve, defined by 
 non-empty set p
 of d-dimensional points, where t : [0, 1] and d > 1.
 real[d] bezier(size_t d, Number)(Number[d][] p, Number t)
     if(d > 1 && isFloatingPoint!Number)
 in
 {
     assert(p.length > 0);
     assert(t >= 0.0L && t <= 1.0L);
 }
 body
 {
     return p.length > 1 ? (1 - t) * p[0..$-1].bezier(t) + t *
 p[1..$].bezier(t) : p[0];
 }

 /// Returns k unidistant points on the bezier curve, defined 
 by non-empty
 set p of d-dimensional points, where k > 0 and d > 1.
 real[d][] bezier(size_t d, Number)(Number[d][] p, size_t k)
     if(d > 1 && isFloatingPoint!Number)
 in
 {
     assert(p.length > 0);
     assert(k > 0);
 }
 body
 {
     Number[d][] result = new Number[d][k];
     foreach(i; 0..k)
         result[k] = p.bezier(i * (1.0L / k));
     return result;
 }


 I would not show this to newcomers, as they would probably go 
 running for
 Go.

 This type of code is quite nice and the reason why I think I 
 am better
 served with D than Go, but newcomers without strong generic 
 programming
 background in other languages might get scared.

 --
 Paulo


 You're right. This is a bit advanced code sample, which uses 
 templates,
 template constraints, contract programming among syntax 
 advantages of D.



At least, with a main() and an input, it would be a bit more 
interesting and illustrative of the "modeling power" of D than 
the examples of the http://dlang.org/index.html home page, which 
are stupid and mostly don't work at all. (even the simplest 
example gives the ridiculous result of 895 until one manually 
breaks the input text with carriage returns).
Jul 16 2012
prev sibling parent "Tobias Pankrath" <tobias pankrath.net> writes:
 This type of code is quite nice and the reason why I think I am 
 better served with D than Go, but newcomers without strong 
 generic programming background in other languages might get 
 scared.

 --
 Paulo


And for people that have no such background the advantages need 
some explanation. It's not obvious, but with some explanation it 
is a good example.
Jul 09 2012