multithreading & sqlite

[monkyyy]

On Monday, 2 February 2026 at 06:54:53 UTC, Lars Johansson wrote:
> On Sunday, 1 February 2026 at 20:49:34 UTC, monkyyy wrote:
>> On Sunday, 1 February 2026 at 12:54:15 UTC, Lars Johansson 
>> wrote:
>>> I put templates on the shelf for now, my skill level is to 
>>> low to understand templates.
>>
>> You need 3 patterns total to write every range function in the 
>> style I suggest; I stand by my original suggestion; the 
>> complexity of template hell comes in when you try to annotate, 
>> introspect, or have a some kind of big ask.
>>
>> Phoboes annotates functions and explodes its line count often 
>> by 10x to 100x
>
> I do not follow. Are you implying there are a category of 
> templates that is relatively easy to understand, and I can 
> avoid what you call template hell. Can you please be a bit more 
> explicit and give an example.

the 3 patterns that are enough to write unannotated range 
functions:

voldemort types: if you have some kind of templated function, 
structs defined inside them just work
```d
auto map(alias F,R)(R r){
   struct map_{
     R r;
     auto front()=>F(r.front);
     void popFront(){r.popFront;}
     bool empty()=>r.empty;
   }
   return map_(r);
}
```

lazy templates: given an empty template argument list, a name can 
exist without being initialized
```d
auto bar(R)(R r){
   struct maybehaslength{
     R r;
     auto front()=>r.front;
     auto length()()=>r.length;
   } //         ^ ^
   return maybehaslength(r);
}
unittest{
   auto foo=iota(int.max).filter!(a=>a>100).bar;
   assert(foo.front==101);
   // assert(foo.length); //errors out here because filter cant 
define length
}
```

understanding default argument resolution; if you want 
counter(10), counter(5,10), and counter(3,7.5,double(.34)); to 
all compile from a single header youll need to understand the 
headers thats, not that trivial.

---

Templates are bad lambda calculus machines that create turning 
machines; if you need to *calculate* something, well, thats means 
learning what I mean by that; if you dont, you dont need a lick 
of theory.