Polymorphic data structures

[ib00]

Is it possible to create polymorphic data structures?

[travisdoor]

Hi, not yet, but that's what I'm currently working on ;)

[travisdoor]

Regarding this, there is very WIP implementation in the master. Compile-time functions can be now used for type generation like this:

Data :: fn (TValue: type) type #comptime {
    return struct {
        value: TValue;
    };
}

set_value :: fn (data: *?T, value: T.value) {
    data.value = value;
}

main :: fn () s32 {
    data: Data(string);
    set_value(&data, "hello!");    
    return 0;
}

[ib00]

This is great!

Couple more questions:

1. Does #comptime essentially mean you can use bl for macros (and compile-time code / data structure generation)?
2. Can you create data structure programmatically by filling out TypeInfo?

[travisdoor]

The #comptime here means that the function is executed directly during compilation, so there is no Data function in the final binary. When the expression data: Data(string) is analyzed the call to Data(string) is replaced by the return value, in this case struct {...} type. So it's not a macro, it does not insert/generate any code.

In general compile-time functions should allow execution of anything, even complex stuff, but it's not ready yet, I use them currently only for generic type generation, just to make some progress with things like hash tables and other containers.

TypeInfo is created automatically for every type introduced in the program, but only in case, it's needed.

I was thinking about some more advanced type generation i.e. loading structure layout from a file, IMHO there will be a lot of problems/bugs for now, but it should be possible in the future... hopefully :D

[travisdoor]

Or more precisely, it's not macro like in C/C++. It does not insert/generate any "user" code in the preprocessor like C.

[ib00]

I see, so #comptime will not be a fancy metaprogramming engine. I think it's tricky to decide what's allowed and
what isn't. It can quickly get out of hand.

What I had in mind was ability to create data structures at run-time (based on some json file or whatever).
For graphics / games applications, this would be super useful.

It could even be done at compile-time of course. Here's an example in circle language:
https://github.com/seanbaxter/shaders#reflection-and-attributes-for-shadertoy-development
where he has a lot of metaprogramming machinery available. With your #comptime, more or less
everything he has would be possible in bl as well.

[travisdoor]

Thanks for the suggestions, I'll take a look at the circle lang, I've never heard about it.

There is one big issue IMHO with a generation of types in runtime, it seems to be against the philosophy of "type-safe language". When you allow this, the types themselves must become mutable somehow, and that can be very bad...