www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - What is your favorite D feature?

reply Seb <seb wilzba.ch> writes:
Hi,

I am currently trying to modernize the D code example roulette on 
the dlang.org front page [1]. Hence, I would love to hear about 
your favorite feature(s) in D.
Ideas:
- favorite language construct
- favorite code sample
- "only possible in D"

Before you ask, yes - I want to add a couple of cool examples to 
dlang.org (and yep the roulette rotation is currently broken [2]).

[1] 
https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
[2] https://github.com/dlang/dlang.org/pull/1757
Jun 21
next sibling parent reply Mike <none none.com> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:

 I would love to hear about your favorite feature(s) in D.
Beginning with most favorite: - CTFE - static if - If you don't consider that part of CTFE - Template Mixins - Templates - Pretty much goes along with the top 2 - String Mixins - Unit Tests DIP1000 may make that list too, if I ever get around to trying it out. Mike
Jun 21
parent reply Seb <seb wilzba.ch> writes:
On Thursday, 22 June 2017 at 01:00:42 UTC, Mike wrote:
 Beginning with most favorite:
  - CTFE
  - static if - If you don't consider that part of CTFE
  - Template Mixins
  - Templates - Pretty much goes along with the top 2
  - String Mixins
  - Unit Tests

 DIP1000 may make that list too, if I ever get around to trying 
 it out.
Nice list, but I was actually looking for more concise, actionable snippets or idea(s) for such. I should have made this clearer. Sorry. For some I have already submitted PRs - the other are still missing a good "WoW" snippet. Ideas?
  - CTFE
-> https://github.com/dlang/dlang.org/pull/1758
  - static if - If you don't consider that part of CTFE
Do you know a more concise example than my commonPrefix one from the Tour? https://tour.dlang.org/tour/en/gems/traits
  - Template Mixins
TBD
  - Templates - Pretty much goes along with the top 2
TBD
  - String Mixins
-> https://github.com/dlang/dlang.org/pull/1762
  - Unit Tests
TBD
Jun 22
parent Mike <none none.com> writes:
On Thursday, 22 June 2017 at 07:10:14 UTC, Seb wrote:

 Nice list, but I was actually looking for more concise, 
 actionable snippets or idea(s) for such.
There are some real gems in this DConf Talk: https://www.youtube.com/watch?v=yMNMV9JlkcQ I started enumerating them on the Wiki here (https://wiki.dlang.org/Tutorials#Design_Patterns) but alas it's still incomplete. Mike
Jun 22
prev sibling next sibling parent Adam D. Ruppe <destructionator gmail.com> writes:
My fav is that familiar code just works.
Jun 21
prev sibling next sibling parent reply "H. S. Teoh via Digitalmars-d" <digitalmars-d puremagic.com> writes:
On Thu, Jun 22, 2017 at 12:48:25AM +0000, Seb via Digitalmars-d wrote:
 Hi,
 
 I am currently trying to modernize the D code example roulette on the
 dlang.org front page [1]. Hence, I would love to hear about your
 favorite feature(s) in D.

 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"
Slices! And preferably in an example where it beats C performance by not needing to duplicate strings everywhere. Built-in unittests... ddoc'd unittests! Though it's hard to think of an example showing this off that's short enough to work for the roulette. Sane template syntax. Template alias parameters. Manipulation of template argument lists. UFCS. Compile-time introspection + UDAs. Loop over a struct defining a set of program configuration parameters, and generate code for parsing command-line arguments that fills in the struct based on field definitions. (You could just transform the struct members into getopt arguments, as implementing this from scratch could be a bear... and ugly to look at. :-D) std.process making it dead easy to invoke an external program, capture its output, all without the ugliness of manually dealing with fork(), execv(), and waitpid().
 Before you ask, yes - I want to add a couple of cool examples to
 dlang.org
[...] You could search for "your code here" in the forum -- that used to be the instructions on submitting code examples back before the website was revamped, and IIRC there have been a handful of suggestions, though AFAIK none was ever actually added to the roulette. T -- Those who don't understand Unix are condemned to reinvent it, poorly.
Jun 21
next sibling parent Jon Degenhardt <jond noreply.com> writes:
On Thursday, 22 June 2017 at 01:13:43 UTC, H. S. Teoh wrote:
 On Thu, Jun 22, 2017 at 12:48:25AM +0000, Seb via Digitalmars-d 
 wrote:

 [snip]

 Slices!  And preferably in an example where it beats C 
 performance by not needing to duplicate strings everywhere.
 ...
For slices the example in blog post I wrote might serve (https://dlang.org/blog/2017/05/24/faster-command-line-tools-in-d/). To shorten it drop the associative array component. For example, sum the values in a specific field. --Jon
Jun 21
prev sibling parent Seb <seb wilzba.ch> writes:
On Thursday, 22 June 2017 at 01:13:43 UTC, H. S. Teoh wrote:
 Slices!  And preferably in an example where it beats C 
 performance by not needing to duplicate strings everywhere.
There's one in the queue, feel free to vote for or destroy it: https://github.com/dlang/dlang.org/pull/1756
 Built-in unittests... ddoc'd unittests!  Though it's hard to 
 think of an example showing this off that's short enough to 
 work for the roulette.
Yes ... ideas welcome ;-)
 Sane template syntax. Template alias parameters. Manipulation 
 of template argument lists.
Do you have anything specific in mind?
 UFCS.
Absolutely agreed, but how do we show this? Range - one of the best uses cases - are already shown.
 Compile-time introspection + UDAs.  Loop over a struct defining 
 a set of program configuration parameters, and generate code 
 for parsing command-line arguments that fills in the struct 
 based on field definitions.  (You could just transform the 
 struct members into getopt arguments, as implementing this from 
 scratch could be a bear... and ugly to look at. :-D)
Ok - I gave it a shot, but it got quite long. Any ideas on trimming it down? https://github.com/dlang/dlang.org/pull/1762
 std.process making it dead easy to invoke an external program, 
 capture
 its output, all without the ugliness of manually dealing with 
 fork(),
 execv(), and waitpid().
I realized std.parallelism gives an excellent showcase as well: https://github.com/dlang/dlang.org/pull/1760 And created another one for std.process: https://github.com/dlang/dlang.org/pull/1761 Feedback welcome!
 You could search for "your code here" in the forum -- that used 
 to be the instructions on submitting code examples back before 
 the website was revamped, and IIRC there have been a handful of 
 suggestions, though AFAIK none was ever actually added to the 
 roulette.
Thanks, but I can only remember spam being posted with "your code here". The search also doesn't show any results for me...
Jun 21
prev sibling next sibling parent reply Brad Anderson <eco gnuk.net> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently broken 
 [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
A very simple vibe app could be added using dub's single-file package format. Something like (I haven't tried this): #!/usr/bin/env dub /+ dub.sdl: name "hello" dependency "vibe-d" version="~>0.8.0-rc.1" +/ import vibe.d; shared static this() { auto settings = new HTTPServerSettings; settings.port = 8080; listenHTTP(settings, &handleRequest); } void handleRequest(HTTPServerRequest req, HTTPServerResponse res) { if (req.path == "/") res.writeBody("Hello, World!", "text/plain"); } // Dependencies fetched, compiled, cached, built against, and result executed // in one command: // $ ./hello.d
Jun 21
parent Seb <seb wilzba.ch> writes:
On Thursday, 22 June 2017 at 01:42:10 UTC, Brad Anderson wrote:
 A very simple vibe app could be added using dub's single-file 
 package format.
Hmm this is a great idea, but it wouldn't be "runnable" on the web. Here's a PR for discussion: https://github.com/dlang/dlang.org/pull/1763
 Something like (I haven't tried this):
You can even go more minimal - the following works: #!/usr/bin/env dub /+ dub.sdl: name "hello_vibed" dependency "vibe-d" version="~>0.8.0-rc.1" versions "VibeDefaultMain" +/ import vibe.d; shared static this() safe { auto settings = new HTTPServerSettings; settings.port = 8080; listenHTTP(settings, (req, res) { res.writeBody("Hello, World: " ~ req.path); }); }
Jun 21
prev sibling next sibling parent Eugene Wissner <belka caraus.de> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently broken 
 [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
ranges nice operator overloading
Jun 21
prev sibling next sibling parent Jon Degenhardt <jond noreply.com> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
A couple more: - std.conv.to - Safe, convenient conversions that just work. - std.regex - Really well done. May be hard to illustrate all the capabilities in a few examples - Pragmatic functional programming constructs. No guessing about performance. Purity with local mutable variables. Interaction with UCFS. --Jon
Jun 21
prev sibling next sibling parent ketmar <ketmar ketmar.no-ip.org> writes:
	"friendship ".writeln = ((_) => "is"~_)(" magic");


	"friendship ".writeln = ((_) => "is"~_)(" magic");

just couldn't resist the temptaion, sorry.
Jun 21
prev sibling next sibling parent reply bauss <jj_1337 live.dk> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently broken 
 [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
These: https://p0nce.github.io/d-idioms/
Jun 21
parent Seb <seb wilzba.ch> writes:
On Thursday, 22 June 2017 at 06:02:54 UTC, bauss wrote:
 On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently 
 broken [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
These: https://p0nce.github.io/d-idioms/
Hehe, I know about p0nce's great work, but I was asking for _your_ favorite D code snippets ;-) Is there any idiom that you like in particular or think it's a good "show-off"?
Jun 22
prev sibling next sibling parent reply Paulo Pinto <pjmlp progtools.org> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently broken 
 [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
Being a GC enabled systems programming language, following the footsteps of Mesa/Cedar and Modula-3.
Jun 21
parent Seb <seb wilzba.ch> writes:
On Thursday, 22 June 2017 at 06:08:07 UTC, Paulo Pinto wrote:
 On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently 
 broken [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
Being a GC enabled systems programming language, following the footsteps of Mesa/Cedar and Modula-3.
Yes :) ... but how do we turn this into an example snippet with < 10 LoC? (I should have been a bit clear on what I was looking for, sorry).
Jun 22
prev sibling next sibling parent reply Ecstatic Coder <ecstatic.coder gmail.com> writes:
Lack of verbosity.

Clear concise code, thanks to the automatic initialization of 
class members, native strings/arrays/maps/slices, UFCS, 
declaration-order independence, etc.

class TOTO
{
     bool IsCool;
     int Age;
     TUTU[] Tutus;
     TOTO[string] Totos;

     void Foo( TUTU tutu )
     {
         Tutus ~= tutu;
         Totos[ tutu.Name ] = tutu.Toto;
     }
}

class TUTU
{
     string Name;
     TOTO Toto;

     this( string name )
     {
         Name = name;
         Toto = new TOTO;
     }
}

void Bar(
     ref TOTO toto
     )
{
     toto.IsCool = !toto.IsCool;
}

void main()
{
     TUTU tutu;
     TOTO toto;

     tutu = new TUTU( "tutu" );

     toto = new TOTO;
     toto.Foo( tutu );
     toto.Bar();
}

Absolutely no syntactic noise !!!

This is often overlooked, while D easily beats all its direct 
competitors (C++, Java, C#, etc) on that point.

Just try to implement the same code as simply in C++ and you will 
be convinced that this is D's strongest feature...

And this is also what makes D feel like a super-powered 
JavaScript when I use it :)
Jun 21
parent reply Seb <seb wilzba.ch> writes:
On Thursday, 22 June 2017 at 06:27:11 UTC, Ecstatic Coder wrote:
 Absolutely no syntactic noise !!!

 This is often overlooked, while D easily beats all its direct 
 competitors (C++, Java, C#, etc) on that point.

 Just try to implement the same code as simply in C++ and you 
 will be convinced that this is D's strongest feature...

 And this is also what makes D feel like a super-powered 
 JavaScript when I use it :)
Thanks a lot, but I was looking for small snippets (< 10 LoC) than could be used to show the awesomeness of D at the roulette on https://dlang.org Any chance you could make your point a bit conciser? :)
Jun 22
next sibling parent Ecstatic Coder <ecstatic.coder gmail.com> writes:
 Thanks a lot, but I was looking for small snippets (< 10 LoC) 
 than could be used to show the awesomeness of D at the roulette 
 on https://dlang.org
 Any chance you could make your point a bit conciser? :)
I agree with you, indeed it is much too long for a carousel ;) And it should be made even simpler. But I still think that the first and only sample code someone should read when coming for the first time on the D website should be this kind of example, which shows how simple and straightforward the D code looks like. It's very important to reassure the visitor curious about D on how easy it is to learn and use D, showing him that D's syntax is familiar, and the code is very readable and concise. Some first-time visitors may be meta-programming experts, but many others (including me) are just looking for a simpler alternative to existing languages, which allows them to quickly program their stuff in an easy and efficient way. And for those looking for a language which allows to program complicated things in a simpler way, as D indeed allows to do it, this should also be shown. But I don't think that this should be the first example someone sees. That said, I'm not totally against code carousel. The one on the Python website is very well done. https://www.python.org/ Its code snippets are very simple on purpose. Python's landing webpage is very encouraging, and shows that this scripting language can be picked up quickly.
Jun 22
prev sibling parent Patrick Schluter <Patrick.Schluter bbox.fr> writes:
On Thursday, 22 June 2017 at 07:00:17 UTC, Seb wrote:
 Thanks a lot, but I was looking for small snippets (< 10 LoC) 
 than could be used to show the awesomeness of D at the roulette
enum E {IN = -1, V1, V2, V3, X1 } mixin({ string code = "enum EBIT : ulong { "~ "init = 0,"; /* We set the dummy init value to 0 */ foreach(Code; __traits(allMembers, E)) { static if(Code == "IN") code ~= "INVALID = -1,"; else code ~= Code~"= 1 << E."~Code~","; } code ~= " ALL = -1, return code ~ "}"; }()); Generates an enum which values depend on the values of another enum. In C or other languages I would needed to write the 2nd enum myself enum EBIT { INVALID = -1, V1= 1 << E.V1, V2= 1 << E.V2, V3= 1 << E.V3, X1= 1 << E.X1, } For a 4 value enum it doesn't look such a big deal but in my real project coming from C, the first enum holds more than 50 regular values and 3 special values. When I have to add or remove a value I have to edit the first enum, but also the 2nd enum, 5 derived lookup tables and 2 functions using a big switch/case with the enum values. In D I edit only the first enum, the rest is auto-generated. As 2nd trick/nice thing here is a function geenrating a switch/case with the enums. string E2thing(E val) { switch(val) { foreach(e; __traits(allMembers, E)) static if(e != "IN") mixin(`case E.`~e~`: return "`~e~`";`); default: return "UNDEFINED"; } }
Jun 22
prev sibling next sibling parent reply qznc <qznc web.de> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently broken 
 [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
H. S. Teoh calendar: https://wiki.dlang.org/Component_programming_with_ranges /** * Formats a year. * Parameters: * year = Year to display calendar for. * monthsPerRow = How many months to fit into a row in the output. * Returns: A range of strings representing the formatted year. */ auto formatYear(int year, int monthsPerRow) { enum colSpacing = 1; return datesInYear(year) // Start by generating all dates for the given year .byMonth() // Group them by month .chunks(monthsPerRow) // Group the months into horizontal rows // Format each row .map!(r => r.formatMonths() // By formatting each month .array() // Storing each month's formatting in a row buffer // Horizontally pasting each respective month's lines together .pasteBlocks(colSpacing) .join("\n")) // Insert a blank line between each row .join("\n\n"); }
Jun 22
parent Seb <seb wilzba.ch> writes:
On Thursday, 22 June 2017 at 08:52:27 UTC, qznc wrote:
 On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 [...]
H. S. Teoh calendar: https://wiki.dlang.org/Component_programming_with_ranges [...]
Yes that's a great example, but sadly not standalone - we can only use Phobos for the example snippets on dlang.org ... The examples need to compile and run, so that a reader can modify and play with them.
Jun 22
prev sibling next sibling parent Era Scarecrow <rtcvb32 yahoo.com> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 I would love to hear about your favorite feature(s) in D.
Arrays include length along with the pointer. Very easy built-in array support with foreach Ranges, that don't treat their input types as 'pointers' and get all levels of confusion, including that you'd have to include two 'maybe pointers'. Constraints on templates, making limiting and specializing very easy. static if & version removing the pre-processor...
Jun 22
prev sibling next sibling parent k-five <vhsu30 yahoo.com> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently broken 
 [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote: Universal Function Call Syntax ( UFCS ) Sample code on my gitgub + screen-shot, https://github.com/k-five/dren main code: recursively renaming files based on Regexes dirEntries( ".", ( args[ 4 ] == "-r" ? SpanMode.depth : SpanMode.shallow ), false ) .filter!( file => !file.name.matchFirst( regex( args[ 1 ] ) ).empty() ) .filter!( file => ( args[ 3 ] == "-f" || args[ 3 ] == "-d" ? ( args[ 3 ] == "-f" ? !file.isDir : !file.isFile ) : ( !file.isSymlink ) ) ) .map!( file => file.name ) .each!( ( string result ) => ( args[ 5 ] == "-y" ? rename( result, replaceFirst( result, regex( args[ 1 ] ), args[ 2 ] ) ) : writeln( "print: ",result, " >> ", replaceFirst( result, regex( args[ 1 ] ), "\033[1;32m" ~ args[ 2 ] ~ "\033[m" ) ) ) );
Jun 22
prev sibling next sibling parent Guillaume Piolat <first.last gmail.com> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
I think "alias this" is a good contender. But actually I like how D deal with names. alias and alias template parameters exposes the identifier, being a type or a value. It is very clean.
Jun 22
prev sibling next sibling parent reply Andrey <andrey kabylin.ru> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently broken 
 [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
My favorite features: - CFTE - UDA - delegates - UFCS - property - Template mixins - Contracts and unittests
Jun 22
parent Andrey <andrey kabylin.ru> writes:
UDA snippet:
 class MyView : View {
      ViewWidget Button okButton;
      ViewWidget("cancelButton") Button myButton;
      GroupViewWidgets Button[3] buttons;
 
      OnClickListener("okButton")
     void onOkButtonClick(Widget widget) {
         ...
     }
 
      Shortcut("TestGroup.cancel")
     void someShortcutAction() {
         ...
     }
 
      OnClickListener("closeButton")
      OnClickListener("cancelButton")
     void onCancelButtonClick(Widget widget) {
         ...
     }
 }
Jun 22
prev sibling next sibling parent Kagamin <spam here.lot> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently broken 
 [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
Is it to mirror python examples? Shouldn't there be simple examples for newbie programmers too?
Jun 23
prev sibling next sibling parent reply Anonymouse <asdf asdf.net> writes:
On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently broken 
 [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
Fairly specific, but foreach (member; someStruct.tupleof). Part of my work on my IRC bot has been to serialise structs into configuration files (since std.json was *non-trivial* to deal with), and foreaching a someStruct.tupleof or a __traits(allMembers, symbol) allows for really, really interesting stuff.
Jun 23
next sibling parent "H. S. Teoh via Digitalmars-d" <digitalmars-d puremagic.com> writes:
On Fri, Jun 23, 2017 at 06:51:13PM +0000, Anonymouse via Digitalmars-d wrote:
[...]
 Fairly specific, but foreach (member; someStruct.tupleof).
 
 Part of my work on my IRC bot has been to serialise structs into
 configuration files (since std.json was *non-trivial* to deal with),
 and foreaching a someStruct.tupleof or a __traits(allMembers, symbol)
 allows for really, really interesting stuff.
Yup! Recently I wrote a module that, given a struct S annotated with certain UDA's, automatically: 1) Fills an instance of S with values extracted from a given range of key/value pairs (with automatic type conversion from string input to the correct field type via the awesome std.conv.to); 2) Displays a usage message listing the name of each field in S, its type, along with a message explaining that the field is for (the message is in a UDA attached to the struct field); 3) Given an instance of S, produces a listing of field names to the current values in the given instance. Put together, these 3 things can basically replace getopt(): you just declare a struct with UDAs attaching descriptions to struct fields, then just pass the program arguments along to this module and you're all set. It will parse the program arguments and fill in the struct for you, automatically generate a helpful usage message, and even dump the values of the obtained settings if you implement a verbose mode, for example. But it gets even better. Yesterday I added a new UDA that lets you split up your struct into multiple nested structs, but have all the field names visible at the top-level, i.e., say you have modules A, B, C, each declaring their own configuration structs: module A; struct Config { Desc("The number of iterations") int x; } module B; struct Config { Desc("The starting value") float y; } module B; struct Config { Desc("The output label") string z; } Then you can combine all of these configuration parameters into a single struct in your main program: struct Config { Denest A.Config aCfg; Denest B.Config bCfg; Denest C.Config cCfg; } The Denest UDA tells the parser that aCfg.x should appear to the user as simply "x", bCfg.y as just "y", and cCfg.z as "z". So the user doesn't have to know how your program is internally divided into modules; all of the settings appear as top-level settings. But internally, you pass Config.aCfg to module A, Config.bCfg to module B, etc., thereby avoiding leaking details about module B to module A, which would happen if you put everything into a single struct (you might end up accidentally having code in module A depend on a setting that belongs to module B, which breaks encapsulation and makes the code harder to maintain). D rawkz, I tell ya. T -- VI = Visual Irritation
Jun 23
prev sibling parent Petar Kirov [ZombineDev] <petar.p.kirov gmail.com> writes:
On Friday, 23 June 2017 at 18:51:13 UTC, Anonymouse wrote:
 On Thursday, 22 June 2017 at 00:48:25 UTC, Seb wrote:
 Hi,

 I am currently trying to modernize the D code example roulette 
 on the dlang.org front page [1]. Hence, I would love to hear 
 about your favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"

 Before you ask, yes - I want to add a couple of cool examples 
 to dlang.org (and yep the roulette rotation is currently 
 broken [2]).

 [1] 
 https://github.com/dlang/dlang.org/pulls?q=is%3Apr+is%3Aopen+label%3A%22Frontpage+example%22
 [2] https://github.com/dlang/dlang.org/pull/1757
Fairly specific, but foreach (member; someStruct.tupleof). Part of my work on my IRC bot has been to serialise structs into configuration files (since std.json was *non-trivial* to deal with), and foreaching a someStruct.tupleof or a __traits(allMembers, symbol) allows for really, really interesting stuff.
Agreed. I have proposed [0] a variation on one of Sebastian's examples that uses that technique, so feel free to chime in with concrete suggestions there or here on the forums. [0]: https://github.com/dlang/dlang.org/pull/1762#issuecomment-310377649
Jun 24
prev sibling parent "H. S. Teoh via Digitalmars-d" <digitalmars-d puremagic.com> writes:
On Thu, Jun 22, 2017 at 12:48:25AM +0000, Seb via Digitalmars-d wrote:
 Hi,
 
 I am currently trying to modernize the D code example roulette on the
 dlang.org front page [1]. Hence, I would love to hear about your
 favorite feature(s) in D.
 Ideas:
 - favorite language construct
 - favorite code sample
 - "only possible in D"
[...] Today, I just got another idea for this: show off std.parallelism, especially parallel foreach!!! Here's the background: I have a program that takes user input, converts it into D code using a code template, invokes dmd to compile it into a shared library, and then loads the shared library so that the main program can call the compiled code directly. The output is a series of images that can be assembled into an animation. The first version of the code looked like this (greatly simplified, of course): void main(string[] args) { auto input = parseUserInput(args); auto libhandle = compile(input); foreach (i; 0 .. n) { auto outfile = File(...); ... // do stuff libhandle(...); // call compiled code ... // more stuff outfile.rawWrite(image); } } When n is large, of course, this runs rather slowly, because it's generating the images one by one. Parallel foreach comes to the rescue: void main(string[] args) { auto input = parseUserInput(args); auto libhandle = compile(input); foreach (i; parallel(iota(0, n))) { // *** auto outfile = File(...); ... // do stuff libhandle(...); // call compiled code ... // more stuff outfile.rawWrite(image); } } The only change is marked in // *** above. It's just a 1-line change, and boom, now the loop automatically spawns worker threads and generates the images in parallel. Instant 6x speedup on my AMD Hexacore machine! This all sounds very obvious, but actually there are some D-specific features at play here that make this even remotely possible: - First of all, I deliberately described the shared library bit, because at first I wasn't sure if std.parallel would Just Work(tm), the reason being that the shared object has global variables, and the loop body does change the values of those global variables. After reading the warning about implicit data sharing between threads in the docs, I was a bit wary of writing the loop as a parallel loop to begin with. Thankfully, TLS comes to the rescue: because the shared object is compiled as D code, the globals sit in the TLS segment, rather than C/C++'s default global storage. So modifying those globals turned out to be completely harmless w.r.t. parallel foreach: each thread would have its own copy of the global, so they don't interfere with each other. More importantly, this holds not only for the main program, but also for the *shared library* loaded via dlopen(). (It was this last part that I wasn't 100% sure about; it was already obvious that if these globals were in the main program, it would be no problem by default. But for this to also extend to manually-loaded shared libraries was a big relief for me.) That was the most tricky bit, but then other D features come together to make it possible to change a linear loop into a parallel loop by basically just editing the foreach statement: - opApply: in spite of being the scorned illegitimate second cousin of the beloved range-based counterparts, this is what made it possible to keep the only difference between a "native" foreach and a parallel foreach just a matter of a simple syntactic change in the foreach aggregate (just add a call to `parallel`). Without this, we'd have to hoist the loop body out into a delegate or some such, and replace the foreach with an awkward call to some obscure function in std.parallel. Not horrible, but just lots of fussy little editing details to take care of. Thanks to opApply, all we needed to do was to essentially add `parallel` to the one line. The compiler takes care of converting the loop body into the requisite delegate, transparently close over the required local variables, etc.. No fuss, no muss. - iota: the underappreciated construct, without which we'd have to manually construct some indexing array or some other such thing for parallel() to work with. I.e., a lot more tedious typing than just a simple 1-line change. - Finally, parallel() itself: one of the most ingenious API designs I've ever seen, it nicely encapsulates the dirty details of managing TaskPools manually, spawning worker threads, assigning Tasks to threads, synchronizing with threads afterwards, and all of that fussy boilerplate that one has to drown in if doing this in a language like C or C++. Thanks to all of the above, D lets you switch from a linear loop to a multithreaded loop just by changing 1 line of code. I don't know of any other imperative language that can boast this. (Of course, functional languages, esp. the pure ones, have this "by default". But we're talking about a dirty, mutating, imperative language with loop bodies that modify *global* variables -- to do this in spite of said mutation of globals, now *that's* an achievement.) T -- English is useful because it is a mess. Since English is a mess, it maps well onto the problem space, which is also a mess, which we call reality. Similarly, Perl was designed to be a mess, though in the nicest of all possible ways. -- Larry Wall
Jun 23