Early review of std.logger

[Jacob Carlborg]

On 2013-11-06 14:21, Dicebot wrote:
> On Tuesday, 5 November 2013 at 08:38:34 UTC, Robert Schadek wrote:
>> Can you give an example, I'm not sure if I know what you mean.
>
> Currently common approach is just adding top-level module imports like
> this:
>
> ```
> module app;
> import std.algorithm;
> ```
>
> It has several issues:
>
> 1) Name clash if two modules define same symbol
> 2) Difficulties with tracking unused imports
> 3) Compilation speed penalty because of eager import in case it is only
> used in uninstantiated code branch.
>
> However, D has 3 totally awesome import features that help to address
> all of this issues:
>
> 1) aliasing imports
> ```
> import algo = std.algorithm;
> ```
>
> It creates the very same namespace one is trying to achieve with
> namespace struct but without extra unused symbols and with full user
> control. Benefits both readability of application (obvious where
> namespace comes from) and readability of imported module (less redundant
> nesting)
>
> 2) importing specific symbols
> ```
> import std.algorithm : remove;
> ```
>
> Often module is used only for one or two functions. Mentioning those
> explicitly will avoid accidental clashes with irrelevant module symbols
> and acts as a nice self-documentation tool.
>
> 3) scope-local imports
> ```
> template tmpl(T)
> {
>      import std.algorithm : remove;
> }
> ```

4) static imports

static import std.stdio;

void main ()
{
     std.stdio.writeln("foo"); // fully qualified name is required
}

2 + 3) combining selective and renamed imports

import io = std.stdio : println = writeln;

void main ()
{
     println("foo");
     io.writeln("bar");
}

6) aliases

import std.stdio;
alias println = writeln;

void main ()
{
     println("foo");
}

-- 
/Jacob Carlborg