DIP Idea: Lazy Imports

I’d like to propose a DIP for adding lazy imports to D.

Motivation

D already has the lazy keyword for function parameters, which works wonders:

• Arguments are only evaluated when (and if) actually used.
• This avoids unnecessary work, prevents allocations, and gives a nice middle ground between eager and manual delegate passing.

It’s a proven feature that shows how well deferred evaluation fits into the language.

Currently, though, import in D is eager: all imported modules are parsed and semantically analyzed during compilation, regardless of whether their symbols are actually referenced. This can cause unnecessary compile-time costs, especially in large projects with deep dependency graphs.

A lazy import would extend the same philosophy of deferred evaluation to the module system: the compiler would defer full analysis of a module until it is actually needed (when a symbol from it is referenced). This reduces compile times and makes dependency management more efficient.

Proposed Syntax

lazy import std.big;

This would mean:

The compiler does not fully load/parse std.big at import time.

If no symbols from std.big are used, the module never impacts compilation.

If symbols are referenced, the compiler processes the module as usual.

Alternatively, the same effect could be achieved with an attribute-style approach:

@lazy import std.big;

On Friday, 3 October 2025 at 19:14:00 UTC, xlogor wrote:

How will the compiler know whether a symbol from the module is referenced without parsing and semantically analyzing the module?

On Friday, 3 October 2025 at 19:14:00 UTC, xlogor wrote:

lazy import std.big;

@lazy import std.big;

All templates functions already are lazy, the std is slow because they get initialized; its a lack of initialization discipline combined with a worse of both worlds policys on templates.

On Friday, 3 October 2025 at 19:30:29 UTC, Paul Backus wrote:

Perhaps this could be limited to renamed/static imports?

    lazy import big = std.big;

On Friday, 3 October 2025 at 20:18:45 UTC, monkyyy wrote:

lazy import std.big;

@lazy import std.big;

D compilers lack incremental compilation; lazy evaluation should be explored further.

On Saturday, 4 October 2025 at 08:54:16 UTC, xlogor wrote:

    lazy import big = std.big;

I suppose that could work.

We could also consider treating renamed and static imports this way by default, without requiring the lazy keyword.

On Saturday, 4 October 2025 at 08:56:47 UTC, xlogor wrote:

Memorization only provides speed ups when it effects the whole pipeline. "Incremental compilation" which already exists and means a terrible idea where you build libs separately.

Push vs pull logistics clash and can easily produce worse of both world results. The c abi is push logistics, theres a push of files you given the compiler with headers and all golbal scope names these get pushed into a pipeline and a executable come out the other end. Templates, out of order evulation and in a sense modules, are pull logistics; modules need to be parsed but a (pure) template is not initialized as a named symbol until used, lerp!Rect maybe be valid but it doesn't exist until used, pulled.

The std and user base have a mix of takes on either embracing c norms or going with templates, you cant fix this with features. The std needs to have a compilation life time theory(we will see if the current plan improve things, Im mildly hopeful that the core vs upper end split will work by accident, but the core team are anti template)

The user base needs education or do find out what the hell these 90 minute compiles from a small minority come from.

We should go full "pull"; and incremental compilation is a "push" (anti-)feature. All imports are already lazy as they can be.

If you want a lazy namespace so a import doesnt exist until called you could try

template big(){
  import big;
}

Then you call big!().writeln;

but this breaks the usual overload rules and ufcs so it cant be made a default behavior.