Capture context surrounding delegate

[Python]

Too much code below, but I cannot reduce it more. The issue is in 
the main function, I want to pass a delegate to a thread with a 
captured value from the surrounding context. At least this was my 
expectation, the delegate should capture any stack value.

Am I doing something wrong?

(please ignore lock abuse, I know that are better ways to do it, 
let's concentrate on problem at hand).

```d
import std.stdio;
import core.thread;

void main()
{
     for (int i = 0; i < 100; ++i)
     {
         auto captured = i;
         //how do i capture i?
         //it's always 99 (or near when first threads are spawned 
before
         //for cycle ends)
         ThreadPool.enqueue(() {
             writefln("Item: %d on thread %d, running %d threads", 
captured, Thread.getThis.id, ThreadPool.threads);
         });
     }

     writeln("all enqueued");
     getchar();
}

struct ThreadPool
{
     private static __gshared _queue_lock = new Object();
     private static __gshared _thread_lock = new Object();
     private static __gshared const(void delegate())[] _queue;
     private static __gshared int threads;

     private static __gshared int _minThreads = 1;
     private static __gshared int _maxThreads = 10;

     private static auto dequeue()
     {
         synchronized(_queue_lock)
         {
             if (_queue.length > 0)
             {
                 auto item = _queue[0];
                 _queue = _queue[1 .. $];
                 return item;
             }
             else
             {
                 return null;
             }
         }
     }

     static void enqueue(void delegate() item)
     {
         synchronized(_queue_lock)
         {
             _queue ~= item;
         }
         resizeIfNeeded();
     }

     private static void resizeIfNeeded()
     {
         synchronized(_thread_lock)
         {
             if (threads < _maxThreads)
             {
                 synchronized(_queue_lock)
                 {
                     if (_queue.length > 0)
                     {
                         new Thread(&run).start();
                         ++threads;
                     }
                 }
             }
         }
     }

     private static void run()
     {
         while (true)
         {
             auto item = dequeue();
             if (item !is null)
             {
                 item();
             }
             else
             {
                 synchronized(_thread_lock)
                 {
                     if (threads > _minThreads)
                     {
                         --threads;
                         break;
                     }
                 }
             }
         }
     }
}



```