## digitalmars.D - Exquisite code samples

• Gor Gyolchanyan (37/37) Jul 09 2012 I've put together a code sample, which could demonstrate the awesome pow...
• Paulo Pinto (9/47) Jul 09 2012 I would not show this to newcomers, as they would probably go
• Gor Gyolchanyan (6/53) Jul 09 2012 You're right. This is a bit advanced code sample, which uses templates,
• renoX (15/18) Jul 10 2012 Hum it show the power of D sure, but IMHO it also show its syntax
• Don Clugston (8/25) Jul 10 2012 Well it used to work vaguely in that way, but it gets very ugly once you...
• renoX (10/46) Jul 17 2012 How about:
• renoX (18/21) Jul 10 2012 Hum it show the power of D sure, but IMHO it also show its syntax
• renoX (16/19) Jul 10 2012 Hum it shows the power of D sure, but IMHO it also shows its
• SomeDude (7/72) Jul 16 2012 At least, with a main() and an input, it would be a bit more
• Tobias Pankrath (3/9) Jul 09 2012 And for people that have no such background the advantages need
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
"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
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
"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

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
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

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
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
"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

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 )

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

I think that grouping together template parameters and

BR,
renoX

PS: Sorry for the multiple posting, the posting didn't seem to
work so I retried..
```
Jul 17 2012
"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

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
"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

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
"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

At least, with a main() and an input, it would be a bit more
interesting and illustrative of the "modeling power" of D than
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
"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