how to do this meta-programming? print the address of random element's address of a variable length of arrays?

[mw]

On Sunday, 13 September 2020 at 10:16:46 UTC, Paul Backus wrote:
> On Sunday, 13 September 2020 at 07:00:36 UTC, mw wrote:
>>
>> Here it is: D wrapper for https://ta-lib.org/
>>
>> https://github.com/mingwugmail/talibd
>>
>> I end up using C macro to generate D functions, the single 
>> template is this one:
>>
>> https://github.com/mingwugmail/talibd/blob/master/source/talibd.h#L117
>> #define DECL_TA_FUNC(TA_FUNC, FUNC_INS, FUNC_OUTS, 
>> expected_lookback) __NL__\
>
> The most straightforward way to do this in D is with a mixin 
> template. Something like:
>
> mixin template DECL_TA_FUNC(string TA_FUNC, FUNC_INS, 
> FUNC_OUTS, int expected_lookback)
> {
>     bool impl(...)
>     {
>         // ...
>     }
>
>     // Could also wrap the whole function in a string mixin,
>     // but this is easier.
>     mixin("alias ", TA_FUNC, " = impl;");
> }
>
> Which you would then use like this:
>
> mixin DECL_TA_FUNC!(
>     "TA_MA",
>     Tuple!(int, "MA_optInTimePeriod", TA_MAType, "opInMAType"),
>     Tuple!(double[], "outMA"),
>     MA_optInTimePeriod - 1
> );


Thanks, I will do the exercise some other day.

But, I'd reflect on my experience so far on compile-time 
meta-programming in D as a novice user, the big problems are:

-- in D, there are too many choices, with no clear guideline 
which one is *THE* one to use for a particular purpose: language 
or library mechanisms? mixin? template? AliasSeq / aliasSeqOf? 
Tuple? (non-)?-eponymous version of ...?; and even for a 
particular option, e.g. Tuple!(int, "MA_optInTimePeriod", 
TA_MAType, "opInMAType"),  there are choices to use either token 
(int) or string ("MA_optInTimePeriod"). And user does not have a 
strong guide on which choice is *THE* way to proceed. Each 
mechanism seems to have / fit a particular purpose, but when you 
start to use it, you'll probably find there are new problems 
come-in later, and you want to revisit the choice you made 
earlier on.

By contrast, in C: there is only *ONE* mechanism, i.e. macro, 
that's it.

-- in D, there is no easy way to convert between token <==> 
string. Given a token, does token.stringof always work to paste 
with other strings to generate a new token? and given a string, 
does mixin!"string" always work to be a valid token?

By contrast, in C: there is only *ONE* way: xxx ## yyy.

-- in D, there is no easy way to see directly the generated 
source code by the compiler at compile-time, which makes the 
debug difficult during development.

By contrast, in C: one can easily see the result via: cpp -P 
foo.h > foo.c


As I said earlier, I'm not very experienced with C macros either, 
however with some googling, I was able to work out a C macro 
version to generate D code; but with all the help so far, I still 
have no confidence that I can work out a solution in D to 
implement this:

```
      bool impl(...)
      {
          // ...
      }
```