www.digitalmars.com         C & C++   DMDScript  

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

reply 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
parent reply 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
next sibling parent reply 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
parent reply 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
parent reply 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
parent 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
prev sibling parent reply Davidl <Davidl 126.com> writes:
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
Mar 20 2007
next sibling parent 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
prev sibling parent reply 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
parent 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