Digital Mars - digitalmars.D - compile-time function in a class?

↑ ↓ ← → Davidl <Davidl 126.com> writes:

static keyword is already used by class.
and i hope

static static compiletimefunc()
{
}
can be recognized as a compiletime func

all i want is the name space protection from my class.

like if i want to do some code injection for my certain class
attributes. like
class abc
{
    mixin(compiletimefunc(`membera,memberb`));
//pusedo code begines:
    static static compiletimefunc(char[]members)
    {
        char []result;
        //parse members to membernames
        result~=3D`private:int _m_`~membernames~`;`;
        result~=3D`public:int member(){return _m_`~membernames~`}`;  //g=
etter
	// loop
	return result;
    }
}

actually the compiletimefunc only used by the class abc, but now i can d=
o
is make it outside the class and polute the name space.

Mar 20 2007

↑ ↓ ← → Tyler Knott <tywebmail mailcity.com> writes:

You don't need to mark compile-time functions as static.  Functions are only
evaluated at compile-time when they can't possibly be evaluated at run-time
(such as in mixin declarations/statements/expressions or as initializers of
static or global variables).  E.g.:

char[] exampleFunc() { return "example"; }

char[] example = exampleFunc(); //This is global, so exampleFunc is executed at
compile-time

void func()
{
    char[] example = exampleFunc(); //Not global or static, so run-time
}

Mar 20 2007

↑ ↓ ← → Charlie <charlie.fats gmail.com> writes:

 You don't need to mark compile-time functions as static.  Functions 




at run-time (such as in mixin declarations/statements/expressions or as 
initializers of static or global variables).  E.g.:

I love compile time functions, but saying 'are only evaluated when they 
cant be at run-time' leaves allot to be desired in terms of ease of use. 
  How do i know for sure its evaluated at run time ?  I could use a 
pragma , but it seems like we have to follow a very thin line to get 
there, it would be extremely nice  if we had someway of explicitly 
saying 'call this at compile time'.  exampleFunc(); maybe ?  That way 
instead of guessing we're doing it at compile-time, we could be certain, 
and also let the programmer know whats going on , instead of him having 
to trace the same thin line.

Charlie



Tyler Knott wrote:
 You don't need to mark compile-time functions as static. 



 
 char[] example = exampleFunc(); //This is global, so exampleFunc is executed
at compile-time
 
 void func()
 {
     char[] example = exampleFunc(); //Not global or static, so run-time
 }

Mar 20 2007

↑ ↓ ← → janderson <askme me.com> writes:

Charlie wrote:
  >> You don't need to mark compile-time functions as static.  Functions 
 are only evaluated at compile-time when they can't possibly be evaluated 
 at run-time (such as in mixin declarations/statements/expressions or as 
 initializers of static or global variables).  E.g.:
 
 I love compile time functions, but saying 'are only evaluated when they 
 cant be at run-time' leaves allot to be desired in terms of ease of use. 
  How do i know for sure its evaluated at run time ?  I could use a 
 pragma , but it seems like we have to follow a very thin line to get 
 there, it would be extremely nice  if we had someway of explicitly 
 saying 'call this at compile time'.  exampleFunc(); maybe ?  That way 
 instead of guessing we're doing it at compile-time, we could be certain, 
 and also let the programmer know whats going on , instead of him having 
 to trace the same thin line.
 
 Charlie
 
 
 
 Tyler Knott wrote:
 You don't need to mark compile-time functions as static. 


 
 char[] example = exampleFunc(); //This is global, so exampleFunc is 
 executed at compile-time

 void func()
 {
     char[] example = exampleFunc(); //Not global or static, so run-time
 }




One way to test if a function works at compile time would be to wrap it 
in a mixin.

Mar 20 2007

↑ ↓ ← → janderson <askme me.com> writes:

janderson wrote:
 Charlie wrote:
  >> You don't need to mark compile-time functions as static.  
 Functions are only evaluated at compile-time when they can't possibly 
 be evaluated at run-time (such as in mixin 
 declarations/statements/expressions or as initializers of static or 
 global variables).  E.g.:

 I love compile time functions, but saying 'are only evaluated when 
 they cant be at run-time' leaves allot to be desired in terms of ease 
 of use.  How do i know for sure its evaluated at run time ?  I could 
 use a pragma , but it seems like we have to follow a very thin line to 
 get there, it would be extremely nice  if we had someway of explicitly 
 saying 'call this at compile time'.  exampleFunc(); maybe ?  That way 
 instead of guessing we're doing it at compile-time, we could be 
 certain, and also let the programmer know whats going on , instead of 
 him having to trace the same thin line.

 Charlie



 Tyler Knott wrote:
 You don't need to mark compile-time functions as static. 



 char[] example = exampleFunc(); //This is global, so exampleFunc is 
 executed at compile-time

 void func()
 {
     char[] example = exampleFunc(); //Not global or static, so run-time
 }




 One way to test if a function works at compile time would be to wrap it 
 in a mixin.


To be explicit, I mean the function call.

const int X = mixin(foo());

Mar 20 2007

↑ ↓ ← → Charlie <charlie.fats gmail.com> writes:

That works well for functions that mixin code, but what if you just want 
to return an integer ?

janderson wrote:
 janderson wrote:
 Charlie wrote:
  >> You don't need to mark compile-time functions as static.  
 Functions are only evaluated at compile-time when they can't possibly 
 be evaluated at run-time (such as in mixin 
 declarations/statements/expressions or as initializers of static or 
 global variables).  E.g.:

 I love compile time functions, but saying 'are only evaluated when 
 they cant be at run-time' leaves allot to be desired in terms of ease 
 of use.  How do i know for sure its evaluated at run time ?  I could 
 use a pragma , but it seems like we have to follow a very thin line 
 to get there, it would be extremely nice  if we had someway of 
 explicitly saying 'call this at compile time'.  exampleFunc(); maybe 
 ?  That way instead of guessing we're doing it at compile-time, we 
 could be certain, and also let the programmer know whats going on , 
 instead of him having to trace the same thin line.

 Charlie



 Tyler Knott wrote:
 You don't need to mark compile-time functions as static. 



 char[] example = exampleFunc(); //This is global, so exampleFunc is 
 executed at compile-time

 void func()
 {
     char[] example = exampleFunc(); //Not global or static, so run-time
 }




 One way to test if a function works at compile time would be to wrap 
 it in a mixin.


 To be explicit, I mean the function call.
 
 const int X = mixin(foo());

Mar 20 2007

↑ ↓ ← → Charlie <charlie.fats gmail.com> writes:

Davidl wrote:
 class test
 {
     static char[] c(){return "a";}
     int a;
     class b
     {
         mixin(c());
     }
 }
 void main()
 {
 
 }
 
 don't u think my example should compile?
 
 i don't violate any thing from evaluating func c from compile-time


I don't think you can instantiate a class at compile time, which is what 
you would need to do.  If all you want to do is mixin variables i 
suggest make a template and mixin it in.

Mar 20 2007

↑ ↓ ← → Alexander Panek <a.panek brainsware.org> writes:

Davidl wrote:
 class test
 {
     static char[] c(){return "a";}
     int a;
     class b
     {
         mixin(c());
     }
 }
 void main()
 {
 
 }
 
 don't u think my example should compile?
 
 i don't violate any thing from evaluating func c from compile-time


AFAIK, to be able to mixin a function, it has to be either inside a 
template, a templated struct, a templated class or just be a template 
function.

Mar 20 2007

↑ ↓ ← → Davidl <Davidl 126.com> writes:

class test
{
	template c(){ static char[] c(){return "int k;";}}
	int a;
	class b
	{
		mixin(c());
	}
}
void main()
{
}


above is a great work around for me, i get name space protect my compile  
time func,
thx for ur hint of what actually compile-time func could be

 Davidl wrote:
 class test
 {
     static char[] c(){return "a";}
     int a;
     class b
     {
         mixin(c());
     }
 }
 void main()
 {
  }
  don't u think my example should compile?
  i don't violate any thing from evaluating func c from compile-time


 AFAIK, to be able to mixin a function, it has to be either inside a  
 template, a templated struct, a templated class or just be a template  
 function.

Mar 20 2007