Introspection: Difference between revisions

=={{header|Ada}}==

Ada doesn't allow you to ask about compiler versions, but you can query specific parameters of the target, such as the range of the standard integer type, or the precision of the standard floating point type:

Put ("Integer range: ");

Put (Integer'First);

Put (Float'Digits);

New_Line;

 

=={{header|C}}==

 

{{works with|C|94 and later}}

#pragma error("C compiler must adhere to at least C99 for the following code.")

#else

/* rest of file */

 

However, there is no facility in C for checking whether individual variables and functions have been declared. In open source, the GNU [[autotools]] are often used for this purpose, doing this kind of check in a shell script and defining symbols such as __HAVE_ABS__ which ''can'' be checked by the preprocessor.

The DMD compiler has macros defined for the version, more easily accessible through std.compiler:

 

static if (version_major < 2 || version_minor > 7) {

// this prevents further compilation

static assert (false, "I can't cope with this compiler version");

 

To check if something compiles or not:

 

static if( __traits(compiles,abs(bloop)) ) {

}

 

Note that this checks that bloop is of a type which abs() accepts. It is generic code; if the type of abs() changes, so will the return type of the function. The test can also be written so that it will work on D version 1:

 

typeof(abs(bloop)) computeAbsBloop() {

return abs(bloop);

}

 

=={{header|E}}==

bloop @ abs

[then] [then]

 

=={{header|MAXScript}}==

=={{header|Perl}}==

{{works with|Perl|5.x}}

require 5.6.1; # ditto

Checking whether a variable exists is kind of daft. Good style dictates that I declare the variables I'm going to use, and then I already know $bloop exists. Checking for the ''value'' of a variable however is something very common.

What if 'bloop' is a computed value? Good style forbids that I dereference willy-nilly variables with unknown names, that's what hashes are good for.

exists $introspect{$computed};

But neither you can do this, for example:

The trick in this example is to use bloop variable by reference ${'bloop'} (otherwise it will be created unconditionally by the compiler). Perl store nametables inside hashes: '::' - for main package and 'xxx::' for package 'xxx'.

In Perl, you cannot check for the existence of built-in functions, of which abs() is one. However in practice that's not a problem because most functions live in classes, and those are easily inspectable at runtime.

use Math::Cephes qw();

 

=={{header|Pop11}}==

 

=={{header|Python}}==

import sys

major, minor, bugfix = sys.version_info[:3]

sys.exit('Python 2 is required')

def defined(name): # LBYL (Look Before You Leap)

return name in globals() or name in locals() or name in vars(__builtins__)

if defined2('bloop') and defined2('abs') and callable(abs):

print abs(bloop)

 

=={{header|Raven}}==

 

=={{header|Ruby}}==

 

=={{header|Tcl}}==