NAME

feature - Perl pragma to enable new syntactic features

SYNOPSIS

    use feature qw(switch say);
    given ($foo) {
        when (1)          { say "\$foo == 1" }
        when ([2,3])      { say "\$foo == 2 || \$foo == 3" }
        when (/^a[bc]d$/) { say "\$foo eq 'abd' || \$foo eq 'acd'" }
        when ($_ > 100)   { say "\$foo > 100" }
        default           { say "None of the above" }
    }

    use feature ':5.10'; # loads all features available in perl 5.10

DESCRIPTION

It is usually impossible to add new syntax to Perl without breaking some existing programs. This pragma provides a way to minimize that risk. New syntactic constructs, or new semantic meanings to older constructs, can be enabled by use feature 'foo', and will be parsed only when the appropriate feature pragma is in scope.

Lexical effect

Like other pragmas (use strict, for example), features have a lexical effect. use feature qw(foo) will only make the feature "foo" available from that point to the end of the enclosing block.

    {
        use feature 'say';
        say "say is available here";
    }
    print "But not here.\n";

no feature

Features can also be turned off by using no feature "foo". This too has lexical effect.

    use feature 'say';
    say "say is available here";
    {
        no feature 'say';
        print "But not here.\n";
    }
    say "Yet it is here.";

no feature with no features specified will turn off all features.

The 'switch' feature

use feature 'switch' tells the compiler to enable the Perl 6 given/when construct.

See "Switch statements" in perlsyn for details.

The 'say' feature

use feature 'say' tells the compiler to enable the Perl 6 say function.

See "say" in perlfunc for details.

the 'state' feature

use feature 'state' tells the compiler to enable state variables.

See "Persistent Private Variables" in perlsub for details.

the 'unicode_strings' feature

use feature 'unicode_strings' tells the compiler to treat strings with codepoints larger than 128 as Unicode. It is available starting with Perl 5.11.3.

In greater detail:

This feature modifies the semantics for the 128 characters on ASCII systems that have the 8th bit set. (See "EBCDIC platforms" below for EBCDIC systems.) By default, unless use locale is specified, or the scalar containing such a character is known by Perl to be encoded in UTF8, the semantics are essentially that the characters have an ordinal number, and that's it. They are caseless, and aren't anything: they're not controls, not letters, not punctuation, ..., not anything.

This behavior stems from when Perl did not support Unicode, and ASCII was the only known character set outside of use locale. In order to not possibly break pre-Unicode programs, these characters have retained their old non-meanings, except when it is clear to Perl that Unicode is what is meant, for example by calling utf8::upgrade() on a scalar, or if the scalar also contains characters that are only available in Unicode. Then these 128 characters take on their Unicode meanings.

The problem with this behavior is that a scalar that encodes these characters has a different meaning depending on if it is stored as utf8 or not. In general, the internal storage method should not affect the external behavior.

The behavior is known to have effects on these areas:

• Changing the case of a scalar, that is, using uc(), ucfirst(), lc(), and lcfirst(), or \L, \U, \u and \l in regular expression substitutions.

• Using caseless (/i) regular expression matching

• Matching a number of properties in regular expressions, such as \w

• User-defined case change mappings. You can create a ToUpper() function, for example, which overrides Perl's built-in case mappings. The scalar must be encoded in utf8 for your function to actually be invoked.

This lack of semantics for these characters is currently the default, outside of use locale. See below for EBCDIC.

To turn on case changing semantics only for these characters, use use feature "unicode_strings".

The other old (legacy) behaviors regarding these characters are currently unaffected by this pragma.

EBCDIC platforms

On EBCDIC platforms, the situation is somewhat different. The legacy semantics are whatever the underlying semantics of the native C language library are. Each of the three EBCDIC encodings currently known by Perl is an isomorph of the Latin-1 character set. That means every character in Latin-1 has a corresponding EBCDIC equivalent, and vice-versa. Specifying no legacy currently makes sure that all EBCDIC characters have the same casing only semantics as their corresponding Latin-1 characters.

FEATURE BUNDLES

It's possible to load a whole slew of features in one go, using a feature bundle. The name of a feature bundle is prefixed with a colon, to distinguish it from an actual feature. At present, the only feature bundle is use feature ":5.10" which is equivalent to use feature qw(switch say state).

Specifying sub-versions such as the 0 in 5.10.0 in feature bundles has no effect: feature bundles are guaranteed to be the same for all sub-versions.

IMPLICIT LOADING

There are two ways to load the feature pragma implicitly :

• By using the -E switch on the command-line instead of -e. It enables all available features in the main compilation unit (that is, the one-liner.)

• By requiring explicitly a minimal Perl version number for your program, with the use VERSION construct, and when the version is higher than or equal to 5.10.0. That is,

      use 5.10.0;

  will do an implicit

      use feature ':5.10';

  and so on. Note how the trailing sub-version is automatically stripped from the version.

  But to avoid portability warnings (see "use" in perlfunc), you may prefer:

      use 5.010;

  with the same effect.

cpanm TestInit

perl -MCPAN -e shell
install TestInit