Policy for exposing range structs

[Anon via Digitalmars-d]

On Thursday, 31 March 2016 at 20:40:03 UTC, Adam D. Ruppe wrote:
> meh, if it is allowed, it is going to happen. Why make it worse 
> when there's so little cost in making it better?

Define "little cost". Whatever compression algorithm chosen will 
need support added to any/all tools that want to demangle D. GDB 
and LLDB currently link to liblzma (on my system, at least. 
Configurations may vary). nm and objdump don't link to any 
compression lib. Good luck convincing binutils to add compression 
dependencies like that for D when they don't need them any other 
mangling schemes.

And no, ddemangle isn't a solution here, as then all those 
projects would need to be able to refer to it, and the best way 
for them to do that is to bundle it. Since ddemangle is written 
in D, that would mean binutils would suddenly depend on having a 
working D compiler. That won't happen in the next decade.

Also, any D code that uses core.demangle for any reason would 
suddenly depend on that compression library.

I'm not even fully convinced that my bootstring idea is low 
enough cost, and it's fairly simple, fast, and memory efficient 
compared to any compression algorithm.

> I often don't actually modify the string at all and by putting 
> the string as a template argument, it enables a kind of 
> compile-time memoization like I talked about here a short while 
> ago: http://stackoverflow.com/a/36251271/1457000
>
> The string may be exceedingly if imported from a file or 
> generated externally and cached:
>
> MyType!(import("definition.txt")) foo;
>
> enum foo = ctfeFunction();
>
> MyType!foo test;

Just assigning to an enum gets you memoization (tested on LDC w/ 
DFE 2.68.2).
I don't see how the template factors into this.

Now, yes, if you call the function directly multiple times 
assigning to different enums, it won't memoize those. And it 
doesn't work lazily how the SO question asked for, but this does:

enum lazily(string name: "foo") = ctfeFunction();

If you don't refer to lazily!"foo", ctfeFunction() never gets 
called. If you do, it gets called once, regardless of how many 
times you use lazily!"foo".

That gives you lazy memoization of any CTFEable function without 
ever needing the function parameters to become template 
parameters.

I'm not sure what MyType is, but that looks like a prime 
candidate for my previous post's mixin examples. If not, you 
could use "definition.txt" as its parameter, and have it import() 
as an implementation detail.

> $ is actually a valid identifier character in C

Nope. $ as an identifier character is a commonly supported 
extension, but code that uses it doesn't compile with `clang 
-std=c11 -Werror -pedantic`.