June 19, 2005
We currently have:

static if (some_const == 5)
static if (is(bar T))

As I mentioned before (before static if), I think it would be very useful to be able to check, with static if or similar, for the existence of functions.

I don't mean linking.  I just mean checking if a function was defined yet.  In its basic form, this doesn't seem that great:

version (Windows)
   import std.c.windows.windows;
else version (linux)
   import std.c.linux.linux;

...

static if (GetCurrentThreadId) // or defined(GetCurrentThreadId), etc.
   id = GetCurrentThreadId(...);
else
   id = pthread_self();

However, it becomes more apparent with a longer example:

version (Windows)
   import std.c.windows.windows;
else version (linux)
   import std.c.linux.linux;
else version (macosx)
   import std.c.macosx.macosx;
else version (beos)
   import std.c.beos.beos;

...

static if (GetCurrentThreadId)
   id = GetCurrentThreadId(...);
else
   id = pthread_self();

Of course, this can be handled by an alias.  But, watch this:

...

static if (!stricmp)
{
   int stricmp(char[] s1, char[] s2)
   {
      ...
   }
}

That comes right from gnuc.c in D's source.  Obviously, D wants to avoid problems where one operating system or vendor defines a function, and another doesn't... but I think it will prove inevitable.

At least with a way to know if things are defined *which doesn't depend on an import always having the same functions forever and everywhere* it's much more possible to handle both versioning, OS, and vendor problems.  This will of course depend on the .lib or .a file containing the functions listed in the import, but for my purposes I'm assuming *that* will always be true.

And, the last use is as I mentioned in the above paragraph: handling different versions of D.  For example, let's say someone ported the DMD compiler (or GDC, whatever) to another system... let's say to a gaming console, like Sony's.  If I wanted my program to compile on their (probably old) version of D, with their probably old phobos, I would be able to use the above for things added to phobos I want to use.

Without this, the above situation would be sticky indeed.  There's no way to know the current D version in the code, afaik, currently... so I would just have to tell the person that they're going to have to wait for the person who ported it to update it (or tell them to *try* compiling the new phobos with their old version.)

That said, maybe it seems like that situation is a bit far fetched... and this doesn't handle !is or anything.  Still, I think it would be helpful - even if D somehow convinces everyone who's made autoconf necessary to make amends.

-[Unknown]
June 20, 2005
"Unknown W. Brackets" <unknown@simplemachines.org> wrote in message news:d93ka0$241e$3@digitaldaemon.com...
> As I mentioned before (before static if), I think it would be very useful to be able to check, with static if or similar, for the existence of functions.
>
> I don't mean linking.  I just mean checking if a function was defined yet.  In its basic form, this doesn't seem that great:

You can already do it:

    static if (typeof(foo))
        ...

will be false if foo is not defined, and true if it is.


June 20, 2005
Typeof, eh?  I noticed you could do &foo, but that of course fails if it's not defined with a compiler error.

Is this documented?  As I said, it seems like a very useful thing to use in many cases.

By the way: (found while checking again...)
http://www.digitalmars.com/d/declaration.html#typeof

printf("%d\n", typeof('c').size);	// prints 1

Should be:

printf("%d\n", typeof('c').sizeof);	// prints 1

And:

int[typeof[p]] a;	// a is of type int[int*]

Should be (?):

int[typeof(p)] a;	// a is of type int[int*]

Anyway, I can't get it to work.  I just get errors....

static if (typeof(foo))
   found ')' when expecting '.' following 'typeof(foo)'

static if (typeid(typeof(foo)))
   undefined identifier foo

static if (typeof(foo).sizeof != 0)
   undefined identifier foo

But, I like the syntax.  I thought adding "defined" or something was bad, and I thought leaving it bare was ugly... typeof really makes it work.  If only it'd compile for me :).

May I suppose this is something changed for 0.128, then?

-[Unknown]


> "Unknown W. Brackets" <unknown@simplemachines.org> wrote in message
> news:d93ka0$241e$3@digitaldaemon.com...
> 
>>As I mentioned before (before static if), I think it would be very
>>useful to be able to check, with static if or similar, for the existence
>>of functions.
>>
>>I don't mean linking.  I just mean checking if a function was defined
>>yet.  In its basic form, this doesn't seem that great:
> 
> 
> You can already do it:
> 
>     static if (typeof(foo))
>         ...
> 
> will be false if foo is not defined, and true if it is.
> 
> 
June 25, 2005
"Unknown W. Brackets" <unknown@simplemachines.org> wrote in message news:d9654v$l5k$1@digitaldaemon.com...
> Typeof, eh?  I noticed you could do &foo, but that of course fails if it's not defined with a compiler error.
>
> Is this documented?  As I said, it seems like a very useful thing to use in many cases.
>
> By the way: (found while checking again...)
> http://www.digitalmars.com/d/declaration.html#typeof
>
> printf("%d\n", typeof('c').size); // prints 1
>
> Should be:
>
> printf("%d\n", typeof('c').sizeof); // prints 1
>
> And:
>
> int[typeof[p]] a; // a is of type int[int*]
>
> Should be (?):
>
> int[typeof(p)] a; // a is of type int[int*]

Good catch, I'll fix it.


> Anyway, I can't get it to work.  I just get errors....
>
> static if (typeof(foo))
>     found ')' when expecting '.' following 'typeof(foo)'
>
> static if (typeid(typeof(foo)))
>     undefined identifier foo
>
> static if (typeof(foo).sizeof != 0)
>     undefined identifier foo
>
> But, I like the syntax.  I thought adding "defined" or something was bad, and I thought leaving it bare was ugly... typeof really makes it work.  If only it'd compile for me :).

Arggh, I goofed. It should be:

    static if ( is(typeof(foo)) )
        ...


Top | Discussion index | About this forum | D home