www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.announce - addle 0.1.0 - argument-dependent lookup for UFCS functions

reply Paul Backus <snarwin gmail.com> writes:
Are you tired of D's sane, straightforward scoping rules? Itching 
for a taste of that old-fashioned C++ madness? Well, itch no 
more: addle is here to help.

addle is a tiny library that implements C++-style 
argument-dependent lookup (ADL) for D, on an opt-in basis. It 
lets you extend existing types with UFCS methods, and share those 
methods seamlessly with code in other modules--no `import` 
required!

Here's a brief example:

     import addle;
     import std.range;

     // Import a type from another module
     import mylib: MyStruct;

     // Define range primitives for MyStruct
     bool empty(MyStruct a) { return false; }
     string front(MyStruct a) { return "ok"; }
     void popFront(MyStruct a) {}

     // MyStruct isn't considered an input range, because
     // std.range can't see our UFCS methods.
     static assert(isInputRange!MyStruct == false);

     // ...but extending it makes those methods visible.
     static assert(isInputRange!(Extended!MyStruct));

     void main()
     {
         import std.range: take, only;
         import std.algorithm: equal;

         MyStruct myStruct;

         // Now we can use all of the standard range algorithms
         assert(
             myStruct.extended
             .take(3)
             .equal(only("ok", "ok", "ok"))
         );
     }

Now available on Dub, by "popular demand"!

Links:
   - Documentation: https://addle.dpldocs.info/addle.html
   - Dub: https://code.dlang.org/packages/addle
   - Github: https://github.com/pbackus/addle
Jun 20
next sibling parent Sebastiaan Koppe <mail skoppe.eu> writes:
On Sunday, 21 June 2020 at 00:06:12 UTC, Paul Backus wrote:
 Now available on Dub, by "popular demand"!

 Links:
   - Documentation: https://addle.dpldocs.info/addle.html
   - Dub: https://code.dlang.org/packages/addle
   - Github: https://github.com/pbackus/addle
Cool. Thanks.
Jun 22
prev sibling next sibling parent Simen =?UTF-8?B?S2rDpnLDpXM=?= <simen.kjaras gmail.com> writes:
On Sunday, 21 June 2020 at 00:06:12 UTC, Paul Backus wrote:
     import addle;
     import std.range;

     // Import a type from another module
     import mylib: MyStruct;

     // Define range primitives for MyStruct
     bool empty(MyStruct a) { return false; }
     string front(MyStruct a) { return "ok"; }
     void popFront(MyStruct a) {}

     // MyStruct isn't considered an input range, because
     // std.range can't see our UFCS methods.
     static assert(isInputRange!MyStruct == false);

     // ...but extending it makes those methods visible.
     static assert(isInputRange!(Extended!MyStruct));

     void main()
     {
         import std.range: take, only;
         import std.algorithm: equal;

         MyStruct myStruct;

         // Now we can use all of the standard range algorithms
         assert(
             myStruct.extended
             .take(3)
             .equal(only("ok", "ok", "ok"))
         );
     }
As a demonstration of what you can do in D, I love this. Maybe one day I'll even find a use for it. Good work! -- Simen
Jun 22
prev sibling parent Atwork <fwafwa fwfafa.com> writes:
On Sunday, 21 June 2020 at 00:06:12 UTC, Paul Backus wrote:
 Are you tired of D's sane, straightforward scoping rules? 
 Itching for a taste of that old-fashioned C++ madness? Well, 
 itch no more: addle is here to help.

 addle is a tiny library that implements C++-style 
 argument-dependent lookup (ADL) for D, on an opt-in basis. It 
 lets you extend existing types with UFCS methods, and share 
 those methods seamlessly with code in other modules--no 
 `import` required!

 Here's a brief example:

     import addle;
     import std.range;

     // Import a type from another module
     import mylib: MyStruct;

     // Define range primitives for MyStruct
     bool empty(MyStruct a) { return false; }
     string front(MyStruct a) { return "ok"; }
     void popFront(MyStruct a) {}

     // MyStruct isn't considered an input range, because
     // std.range can't see our UFCS methods.
     static assert(isInputRange!MyStruct == false);

     // ...but extending it makes those methods visible.
     static assert(isInputRange!(Extended!MyStruct));

     void main()
     {
         import std.range: take, only;
         import std.algorithm: equal;

         MyStruct myStruct;

         // Now we can use all of the standard range algorithms
         assert(
             myStruct.extended
             .take(3)
             .equal(only("ok", "ok", "ok"))
         );
     }

 Now available on Dub, by "popular demand"!

 Links:
   - Documentation: https://addle.dpldocs.info/addle.html
   - Dub: https://code.dlang.org/packages/addle
   - Github: https://github.com/pbackus/addle
That's pretty neat. I wonder if something like that could have been used when checking types in phobos? Probably wouldn't be implemented as I can imagine a performance impact during compilation tho.
Jun 23