On 19.05.22 12:15, Chris Katko wrote:
> given
> ```D
> struct COLOR
> {
> float r, g, b, a; // a is alpha (opposite of transparency)
> }
> 
> auto red   = COLOR(1,0,0,1);
> auto green = COLOR(0,1,0,1);
> auto blue  = COLOR(0,0,1,1);
> auto white = COLOR(1,1,1,1);
> //etc
> ```
> 
> is there a way to do:
> ```D
> auto myColor = GREY!(0.5);
> // where GREY!(0.5) becomes COLOR(0.5, 0.5, 0.5, 1.0);
> ```

What's wrong with a simple plain function?

COLOR grey(float rgb)
{
    return COLOR(rgb, rgb, rgb, 1);
}
auto myColor = grey(0.5);

On Thursday, 19 May 2022 at 10:35:30 UTC, ag0aep6g wrote:
> On 19.05.22 12:15, Chris Katko wrote:
>> given
>> ```D
>> struct COLOR
>> {
>> float r, g, b, a; // a is alpha (opposite of transparency)
>> }
>> 
>> auto red   = COLOR(1,0,0,1);
>> auto green = COLOR(0,1,0,1);
>> auto blue  = COLOR(0,0,1,1);
>> auto white = COLOR(1,1,1,1);
>> //etc
>> ```
>> 
>> is there a way to do:
>> ```D
>> auto myColor = GREY!(0.5);
>> // where GREY!(0.5) becomes COLOR(0.5, 0.5, 0.5, 1.0);
>> ```
>
> What's wrong with a simple plain function?
>
> COLOR grey(float rgb)
> {
>     return COLOR(rgb, rgb, rgb, 1);
> }
> auto myColor = grey(0.5);

Yeah that occurred to me as I was falling asleep. Though, do I have to a specify

```D
static auto myColor = grey(0.5);
```
to ensure it's done at compile time? It's not the end of the world, but ideally, these are static / hardcoded values that can be used thousands of times a second.

On Friday, 20 May 2022 at 00:12:44 UTC, Chris Katko wrote:

> Yeah that occurred to me as I was falling asleep. Though, do I have to a specify
>
> ```D
> static auto myColor = grey(0.5);
> ```
> to ensure it's done at compile time? It's not the end of the world, but ideally, these are static / hardcoded values that can be used thousands of times a second.

If the declarations are at module scope, `static` has no effect, and CTFE will be used for initialization.

On Friday, 20 May 2022 at 02:30:10 UTC, Mike Parker wrote:
> On Friday, 20 May 2022 at 00:12:44 UTC, Chris Katko wrote:
>
>> Yeah that occurred to me as I was falling asleep. Though, do I have to a specify
>>
>> ```D
>> static auto myColor = grey(0.5);
>> ```
>> to ensure it's done at compile time? It's not the end of the world, but ideally, these are static / hardcoded values that can be used thousands of times a second.
>
> If the declarations are at module scope, `static` has no effect, and CTFE will be used for initialization.

So wait, that means if I have a module with extra stuff like

````D
colors.d

auto red =
// grey
````

and then in my other file
````D
auto white = grey(1.0);
````

It won't use CTFE? Why is there a local module requirement?

On Friday, 20 May 2022 at 14:54:31 UTC, Christopher Katko wrote:

> So wait, that means if I have a module with extra stuff like
>
> ````D
> colors.d
>
> auto red =
> // grey
> ````
>
> and then in my other file
> ````D
> auto white = grey(1.0);
> ````
>
> It won't use CTFE? Why is there a local module requirement?

I'm not sure what you mean by "local module requirement". The static storage class means that a variable will be around for the lifetime of the program (or more specifically in D's case, the lifetime of the thread). Module-scope variables are static by default.