digitalmars.D.learn - String Metaprogramming
- Clayton (27/27) Jul 18 2015 Am new to D programming, am considering it since it supports
- Adam D. Ruppe (6/9) Jul 18 2015 That's not true in D, you can just write a regular function and
- Clayton (30/39) Jul 18 2015 Thanks , you were right . It seems there are some key words
- anonymous (11/21) Jul 18 2015 `for` loops work just fine in CTFE. `foreach` is usually nicer,
- E.S. Quinn (16/43) Jul 18 2015 Actually, the main things you can't do in CTFE are FPU math
- Nicholas Wilson (24/48) Jul 18 2015 change function signature to
Am new to D programming, am considering it since it supports
compile-time function execution . My challenge is how can I
re-implement the function below so that it is fully executed in
compile-time. The function should result to tabel1 being computed
at compile-time. There seems to be a lot of mutation happening
here yet I have heard no mutation should take place in
meta-programming as it subscribes to functional programming
paradigm.
void computeAtCompileTime( ref string pattern ,ref int[char]
tabel1){
int size = to!int(pattern.length) ;
foreach( c; ALPHABET){
tabel1[c] = size;
}
for( int i=0;i<size -1 ; ++i){ //Initialise array
tabel1[pattern[i]] = size -i-1;
pragma(msg, format("reached pattern
table1[pattern[i]]=(%s) here",
table1[pattern[i]].stringof ~" v="~ (size
-i-1).stringof));
}
}
Jul 18 2015
On Saturday, 18 July 2015 at 13:48:20 UTC, Clayton wrote:There seems to be a lot of mutation happening here yet I have heard no mutation should take place in meta-programming as it subscribes to functional programming paradigm.That's not true in D, you can just write a regular function and evaluate it in a compile time context, like initializing a static variable. You usually don't need to write special code for compile time stuff in D.
Jul 18 2015
On Saturday, 18 July 2015 at 13:56:36 UTC, Adam D. Ruppe wrote:On Saturday, 18 July 2015 at 13:48:20 UTC, Clayton wrote:Thanks , you were right . It seems there are some key words though which one has to use so that the code gets executed on compile-time .For example I had to change the second forloop to a foreach loop, and then put and enum to ensure that TableFromCompiler gets evaluated at compiletime. Having written the code this way though gives rise to some other question, D supports 2 approches to compiletime metaprogramming i.e. CTFE and Templates, it seems am not very sure which paradigm my code falls in. import std.stdio; import std.string; import std.conv; I[C] computeAtCompileTime(S ,C,I)( const S pattern ){ I[C] table1; const int size = to!int(pattern.length) ;//Length of the pattern to be matched foreach( c; ALPHABET){ //Initialise array table1[c] = size; } foreach(i; 0..size-1){ table1[pattern[i]] = size -i-1; } return table1; } void main(){ enum TableFromCompiler = computeAtCompileTime!(const string ,char, int)(pattern); writeln(TableFromCompiler); }There seems to be a lot of mutation happening here yet I have heard no mutation should take place in meta-programming as it subscribes to functional programming paradigm.That's not true in D, you can just write a regular function and evaluate it in a compile time context, like initializing a static variable. You usually don't need to write special code for compile time stuff in D.
Jul 18 2015
"anonymous" <anonymous example.com> On Saturday, 18 July 2015 at 16:18:30 UTC, Clayton wrote:Thanks , you were right . It seems there are some key words though which one has to use so that the code gets executed on compile-time .For example I had to change the second forloop to a foreach loop,`for` loops work just fine in CTFE. `foreach` is usually nicer, though (regardless of CTFE or not).and then put and enum to ensure that TableFromCompiler gets evaluated at compiletime. Having written the code this way though gives rise to some other question, D supports 2 approches to compiletime metaprogramming i.e. CTFE and Templates, it seems am not very sure which paradigm my code falls in.Your computeAtCompileTime is a template that results in a function when instantiated. You're calling such a generated function and you're assigning the result to an enum, which makes it a CTFE call. So there's both CTFE and a template in your code. You could probably do the whole pre-computation without CTFE, using only templates. But (here) CTFE is more straight forward as you can just write normal run time D.
Jul 18 2015
On Saturday, 18 July 2015 at 13:48:20 UTC, Clayton wrote:
Am new to D programming, am considering it since it supports
compile-time function execution . My challenge is how can I
re-implement the function below so that it is fully executed in
compile-time. The function should result to tabel1 being
computed at compile-time. There seems to be a lot of mutation
happening here yet I have heard no mutation should take place
in meta-programming as it subscribes to functional programming
paradigm.
void computeAtCompileTime( ref string pattern ,ref int[char]
tabel1){
int size = to!int(pattern.length) ;
foreach( c; ALPHABET){
tabel1[c] = size;
}
for( int i=0;i<size -1 ; ++i){ //Initialise array
tabel1[pattern[i]] = size -i-1;
pragma(msg, format("reached pattern
table1[pattern[i]]=(%s) here",
table1[pattern[i]].stringof ~" v="~ (size
-i-1).stringof));
}
}
Actually, the main things you can't do in CTFE are FPU math
operations (much of std.math has issues unfortunately), compiler
intrinsics, pointer/union operations, and I/O. I don't
immediately see anything that will cause issues with CTFE in that
function. However, sometimes the compiler isn't smart enough to
figure out that it should be doing that, but you can force the
compiler to try CTFE using this pattern
int ctfeFunc() {
}
void main() {
enum val = ctfeFunc();
}
enums are manifest constants, and thus must be computable at
compile time, so this will issue an error if something in your
function can't CTFE.
Jul 18 2015
On Saturday, 18 July 2015 at 13:48:20 UTC, Clayton wrote:Am new to D programming, am considering it since it supports compile-time function execution . My challenge is how can I re-implement the function below so that it is fully executed in compile-time. The function should result to tabel1 being computed at compile-time. There seems to be a lot of mutation happening here yet I have heard no mutation should take place in meta-programming as it subscribes to functional programming paradigm.void computeAtCompileTime( ref string pattern ,ref int[char] tabel1){change function signature to int[char] function(string) or as the char type is the index probably better of as int[256] function(string). also probably no need to take pattern by ref as it is effectively struct{ size_t length; char* ptr;}. also we aren't going to modify it. int[256] computeAtCompileTime(string pattern) {int size = to!int(pattern.length) ;pattern.length is a size_t no need to change its type in another variable. you are unlikely to be dealing with string longer than 2^32 (also signedness) but w/e int[256] ret; // implicitly initialised to int.init (i.e. 0)foreach( c; ALPHABET){ tabel1[c] = size; } for( int i=0;i<size -1 ; ++i){ //Initialise array tabel1[pattern[i]] = size -i-1;can just foreach over pattern foreach(i, c; pattern) ret[c] = pattern.length - i -1;pragma(msg, format("reached pattern table1[pattern[i]]=(%s) here", table1[pattern[i]].stringof ~" v="~ (size -i-1).stringof)); }}if you want this to be not callable at runtime then wrap the main body (sans variable declaration) with if (__ctfe) { ... }
Jul 18 2015
On Saturday, 18 July 2015 at 16:01:25 UTC, Nicholas Wilson wrote:On Saturday, 18 July 2015 at 13:48:20 UTC, Clayton wrote:Thanks Nicholas , I have integrated some of your advice on the edited code i.e. foreach and ref in pattern . Hope I fully understood what you meant. Am yet to look whether I still need to change the signature . I have heared there are two approaches to this, Where does one really draw the line between CTFE and Template metaprogramming?[...][...]change function signature to int[char] function(string) or as the char type is the index probably better of as int[256] function(string). also probably no need to take pattern by ref as it is effectively struct{ size_t length; char* ptr;}. also we aren't going to modify it. int[256] computeAtCompileTime(string pattern) {[...]pattern.length is a size_t no need to change its type in another variable. you are unlikely to be dealing with string longer than 2^32 (also signedness) but w/e int[256] ret; // implicitly initialised to int.init (i.e. 0)[...]can just foreach over pattern foreach(i, c; pattern) ret[c] = pattern.length - i -1;[...][...]if you want this to be not callable at runtime then wrap the main body (sans variable declaration) with if (__ctfe) { ... }
Jul 18 2015
Thanks Nicholas , I have integrated some of your advice on the edited code i.e. foreach and ref in pattern . Hope I fully understood what you meant. Am yet to look whether I still need to change the signature . I have heared there are two approaches to this, Where does one really draw the line between CTFE and Template metaprogramming?Template metaprogramming == "abuse the template facility in C++ to run a program in compile time" used to be the only way to execute something at compile time in C++. In D you don't want to do that as writing such code is a matter of putting an enum or static at the right place. Still, you can use templates to achieve your goal, if that helps.
Jul 18 2015