addle 0.1.0 - argument-dependent lookup for UFCS functions

[Paul Backus]

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