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));
	}

	
	
	
}

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.

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.

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)
{
     ...

}

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:
>> 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.


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);
 }

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:
>> [...]
>
>
>> [...]
>
> 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)
> {
>      ...
>
> }
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?

> 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.

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.