perl5i - Fix as much of Perl 5 as possible in one pragma
use perl5i::1; or $ perl5i your_script.pl
Perl 5 has a lot of warts. There's a lot of individual modules and techniques out there to fix those warts. perl5i aims to pull the best of them together into one module so you can turn them on all at once.
This includes adding features, changing existing core functions and changing defaults. It will likely not be 100% backwards compatible with Perl 5, though it will be 99%, perl5i will try to have a lexical effect.
Please add to this imaginary world and help make it real, either by telling me what Perl looks like in your imagination (http://github.com/schwern/perl5i/issues) or make a fork (forking on github is like a branch you control) and implement it yourself.
Because perl5i plans to be incompatible in the future, you do not simply use perl5i. You must declare which major version of perl5i you are using. You do this like so:
use perl5i
# Use perl5i major version 1 use perl5i::1;
Thus the code you write with, for example, perl5i::1 will always remain compatible even as perl5i moves on.
perl5i::1
If you want to be daring, you can use perl5i::latest to get the latest version.
use perl5i::latest
If you want your module to depend on perl5i, you should depend on the versioned class. For example, depend on perl5i::1 and not perl5i.
perl5i
See "VERSIONING" for more information about perl5i's versioning scheme.
perl5i enables each of these modules and adds/changes these functions. We'll provide a brief description here, but you should look at each of their documentation for full details.
Every object (and everything is an object) now has a meta object associated with it. Using the meta object you can ask things about the object which were previously over complicated. For example...
# the object's class my $class = $obj->mo->class; # its parent classes my @isa = $obj->mo->isa; # the complete inheritance hierarchy my @complete_isa = $obj->mo->linear_isa; # the reference type of the object my $reftype = $obj->mo->reftype;
A meta object is used to avoid polluting the global method space. mo was chosen to avoid clashing with Moose's meta object.
mo
See perl5i::Meta for complete details.
autobox allows methods to be defined for and called on most unblessed variables. This means you can call methods on ordinary strings, lists and hashes! It also means perl5i can add a lot of functionality without polluting the global namespace.
autobox::Core wraps a lot of Perl's built in functions so they can be called as methods on unblessed variables. @a->pop for example.
@a->pop
autobox::dump defines a perl method that returns Data::Dumper style serialization of the results of the expression. It should work on any scalar, list, hash or reference.
perl
$scalar_reference->alias( @identifiers ); @alias->alias( @identifiers ); %hash->alias( @identifiers ); (\&code)->alias( @identifiers );
Aliases a variable to a new global name.
my $code = sub { 42 }; $code->alias( "foo" ); print foo(); # prints 42
It will work on everything except scalar references.
our %stuff; %other_hash->alias( "stuff" ); # %stuff now aliased to %other_hash
It is not a copy, changes to one will change the other.
my %things = (foo => 23); our %stuff; %things->alias( "stuff" ); # alias %things to %stuff $stuff{foo} = 42; # change %stuff say $things{foo}; # and it will show up in %things
Multiple @identifiers will be joined with '::' and used as the fully qualified name for the alias.
my $class = "Some::Class"; my $name = "foo"; sub { 99 }->alias( $class, $name ); print Some::Class->foo; # prints 99
If there is just one @identifier and it has no "::" in it, the current caller will be prepended. $thing->alias("name") is shorthand for $thing->alias(CLASS, "name")
$thing->alias("name")
$thing->alias(CLASS, "name")
Due to limitations in autobox, non-reference scalars cannot be aliased. Alias a scalar ref instead.
my $thing = 23; $thing->alias("foo"); # error my $thing = \23; $thing->alias("foo"); # $foo is now aliased to $thing
This is basically a nicer way to say:
no strict 'refs'; *{$package . '::'. $name} = $reference;
perl5i adds some methods to scalars of its own.
my $centered_string = $string->center($length); my $centered_string = $string->center($length, $character);
Centers $string between $character. $centered_string will be of length $length.
$character defaults to " ".
$character
say "Hello"->center(10); # " Hello "; say "Hello"->center(10, '-'); # "---Hello--";
center() will never truncate $string. If $length is less than $string->length it will just return $string.
center()
$string
$string->length
say "Hello"->center(4); # "Hello";
my $rounded_number = $number->round;
Round to the nearest integer.
my $new_number = $number->round_up;
Rounds the $number up.
2.45->round_up; # 3
ceil() is a synonym for round_up().
my $new_number = $number->round_down;
Rounds the $number down.
2.45->round_down; # 2
floor() is a synonyn for round_down().
$is_a_number = $thing->is_number;
Returns true if $thing is a number understood by Perl.
12.34->is_number; # true "12.34"->is_number; # also true "eleven"->is_number; # false
$is_positive = $thing->is_positive;
Returns true if $thing is a positive number.
0 is not positive.
$is_negative = $thing->is_negative;
Returns true if $thing is a negative number.
0 is not negative.
$is_an_integer = $thing->is_integer;
Returns true if $thing is an integer.
12->is_integer; # true 12.34->is_integer; # false "eleven"->is_integer; # false
A synonym for is_integer
$is_a_decimal_number = $thing->is_decimal;
Returns true if $thing is a decimal number.
12->is_decimal; # false 12.34->is_decimal; # true ".34"->is_decimal; # true "point five"->is_decimal; # false
$module->load(@args); $path->load(@args);
A thin wrapper around Module::Load::load(). It will load a module from a scalar without requiring you to do funny things like eval require $module. It accepts both module names and file paths.
Module::Load::load()
eval require $module
# like "use $module qw(foo bar);" if that worked $module->load(qw(foo bar));
Note that $module->load does not import anything. This may change in the future.
$module->load
my $wrapped = $string->wrap( width => $cols, separator => $sep );
Wraps $string to width $cols, breaking lines at word boundries using separator $sep.
If no width is given, $cols defaults to 76. Default line separator is the newline character "\n".
See Text::Wrap for details.
my $trimmed = $string->trim; my $trimmed = $string->trim($character_set);
Trim whitespace. ltrim() trims off the start of the string (left), rtrim() off the end (right) and trim() off both the start and end.
my $string = ' testme'->ltrim; # 'testme' my $string = 'testme '->rtrim; # 'testme' my $string = ' testme '->trim; # 'testme'
They all take an optional $character_set which will determine what characters should be trimmed. It follows regex character set syntax so A-Z will trim everything from A to Z. Defaults to \s, whitespace.
A-Z
\s
my $string = '-> test <-'->trim('-><'); # ' test '
my $name = 'joe smith'->title_case; # Joe Smith
Will uppercase every word character that follows a wordbreak character.
All the functions from List::Util and select ones from List::MoreUtils are all available as methods on unblessed arrays and array refs.
first, max, maxstr, min, minstr, minmax, shuffle, reduce, sum, any, all, none, true, false, uniq and mesh.
The have all been altered to return array refs where applicable in order to allow chaining.
@array->grep(sub{ $_->is_number })->sum->say;
Calculate the difference between two (or more) arrays:
my @a = ( 1, 2, 3 ); my @b = ( 3, 4, 5 ); my @diff_a = @a->diff(\@b) # [ 1, 2 ] my @diff_b = @b->diff(\@a) # [ 4, 5 ]
Diff returns all elements in array @a that are not present in array @b. Item order is not considered: two identical elements in both arrays will be recognized as such disregarding their index.
@a
@b
[ qw( foo bar ) ]->diff( [ qw( bar foo ) ] ) # empty, they are equal
For comparing more than two arrays:
@a->diff(\@b, \@c, ... )
All comparisons are against the base array (@a in this example). The result will be composed of all those elements that were present in @a and in none other.
It also works with nested data structures; it will traverse them depth-first to assess whether they are identical or not. For instance:
[ [ 'foo ' ], { bar => 1 } ]->diff([ 'foo' ]) # [ { bar => 1 } ]
In the case of overloaded objects (i.e., DateTime, URI, Path::Class, etc.), it tries its best to treat them as strings or numbers.
my $uri = URI->new("http://www.perl.com"); my $uri2 = URI->new("http://www.perl.com"); [ $uri ]->diff( [ "http://www.perl.com" ] ); # empty, they are equal [ $uri ]->diff( [ $uri2 ] ); # empty, they are equal
my @a = (1 .. 10); my @b = (5 .. 15); my @intersection = @a->intersect(\@b) # [ 5 .. 10 ];
Performs intersection between arrays, returning those elements that are present in all of the argument arrays simultaneously.
As with diff(), it works with any number of arrays, nested data structures of arbitrary depth, and handles overloaded objects graciously.
diff()
Exchanges values for keys in a hash.
my %things = ( foo => 1, bar => 2, baz => 5 ); my %flipped = %things->flip; # { 1 => foo, 2 => bar, 5 => baz }
If there is more than one occurence of a certain value, any one of the keys may end up as the value. This is because of the random ordering of hash keys.
# Could be { 1 => foo }, { 1 => bar }, or { 1 => baz } { foo => 1, bar => 1, baz => 1 }->flip;
Because hash references cannot usefully be keys, it will not work on nested hashes.
{ foo => [ 'bar', 'baz' ] }->flip; # dies
Recursively merge two or more hashes together using Hash::Merge::Simple.
my $a = { a => 1 }; my $b = { b => 2, c => 3 }; $a->merge($b); # { a => 1, b => 2, c => 3 }
For conflicting keys, rightmost precedence is used:
my $a = { a => 1 }; my $b = { a => 100, b => 2}; $a->merge($b); # { a => 100, b => 2 } $b->merge($a); # { a => 1, b => 2 }
It also works with nested hashes, although it won't attempt to merge array references or objects. For more information, look at the Hash::Merge::Simple docs.
Perl6::Caller causes caller to return an object in scalar context.
caller
die now always returns an exit code of 255 instead of trying to use $! or $? which makes the exit code unpredictable. If you want to exit with a message and a special exit code, use warn then exit.
die
$!
$?
warn
exit
utf8 lets you put UTF8 encoded strings into your source code. This means UTF8 variable and method names, strings and regexes.
It means strings will be treated as a set of characters rather than a set of bytes. For example, length will return the number of characters, not the number of bytes.
length
length("perl5i is MËTÁŁ"); # 15, not 18
@ARGV will be read as UTF8.
@ARGV
STDOUT, STDIN, STDERR and all newly opened filehandles will have UTF8 encoding turned on. Consequently, if you want to output raw bytes to a file, such as outputting an image, you must set binmode $fh.
binmode $fh
English gives English names to the punctuation variables; for instance, <$@> is also <$EVAL_ERROR>. See perlvar for details.
<$@
<$EVAL_ERROR
It does not load the regex variables which affect performance. $PREMATCH, $MATCH, and $POSTMATCH will not exist. See the p modifier in perlre for a better alternative.
$PREMATCH
$MATCH
$POSTMATCH
p
Modern::Perl turns on strict and warnings, enables all the 5.10 features like given/when, say and state, and enables C3 method resolution order.
given/when
say
state
Provides CLASS and $CLASS alternatives to __PACKAGE__.
CLASS
$CLASS
__PACKAGE__
File::chdir gives you $CWD representing the current working directory and it's assignable to chdir. You can also localize it to safely chdir inside a scope.
$CWD
chdir
File::stat causes stat to return an object in scalar context.
stat
time, localtime, and gmtime are replaced with DateTime objects. They will all act like the core functions.
time
localtime
gmtime
# Sat Jan 10 13:37:04 2004 say scalar gmtime(2**30); # 2004 say gmtime(2**30)->year; # 2009 (when this was written) say time->year;
gmtime() and localtime() will now safely work with dates beyond the year 2038 and before 1901 (the exact range is not defined, but it's well into a couple million years in either direction).
gmtime()
localtime()
Module::Load adds load which will load a module from a scalar without requiring you to do funny things like eval require $module.
load
Turns filehandles into objects so you can call methods on them. The biggest one is autoflush rather than mucking around with $| and select.
autoflush
$|
select
$fh->autoflush(1);
autodie causes system and file calls which can fail (open, system, and chdir, for example) to die when they fail. This means you don't have to put or die at the end of every system call, but you do have to wrap it in an eval block if you want to trap the failure.
open
system
or die
eval
autodie's default error messages are pretty smart.
All of autodie will be turned on.
autovivification fixes the bug/feature where this:
$hash = {}; $hash->{key1}{key2};
Results in $hash->{key1} coming into existence. That will no longer happen.
$hash->{key1}
want() generalizes the mechanism of the wantarray function, allowing a function to determine the context it's being called in. Want distinguishes not just scalar v. array context, but void, lvalue, rvalue, boolean, reference context, and more. See perldoc Want for full details.
want()
Try::Tiny gives support for try/catch blocks as an alternative to eval BLOCK. This allows correct error handling with proper localization of $@ and a nice syntax layer:
eval BLOCK
# handle errors with a catch handler try { die "foo"; } catch { warn "caught error: $_"; }; # just silence errors try { die "foo"; };
See perldoc Try::Tiny for details.
There is a perl5i command line program installed with perl5i (Windows users get perl5i.bat). This is handy for writing one liners.
perl5i -e 'gmtime->year->say'
And you can use it on the #! line.
#!
#!/usr/bin/perl5i gmtime->year->say;
Some parts are not lexical.
See http://github.com/schwern/perl5i/issues/labels/bug for a complete list.
Please report bugs at http://github.com/schwern/perl5i/issues/ or email mailto:perl5i@googlegroups.com.
perl5i follows the Semantic Versioning policy, http://semver.org. In short...
Versions will be of the form X.Y.Z.
0.Y.Z may change anything at any time.
Incrementing X (ie. 1.2.3 -> 2.0.0) indicates a backwards incompatible change.
Incrementing Y (ie. 1.2.3 -> 1.3.0) indicates a new feature.
Incrementing Z (ie. 1.2.3 -> 1.2.4) indicates a bug fix or other internal change.
Inspired by chromatic's Modern::Perl and in particular http://www.modernperlbooks.com/mt/2009/04/ugly-perl-a-lesson-in-the-importance-of-language-design.html.
I totally didn't come up with the "Perl 5 + i" joke. I think it was Damian Conway.
Thanks to our contributors: Chas Owens, Darian Patrick, rjbs, chromatic, Ben Hengst, Bruno Vecchi and anyone else I've forgotten.
Thanks to Flavian and Matt Trout for their signature and Devel::Declare work.
Thanks to all the CPAN authors upon whom this builds.
Copyright 2009-2010, Michael G Schwern <schwern@pobox.com>
This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
See http://www.perl.com/perl/misc/Artistic.html
Repository: http://github.com/schwern/perl5i/tree/master Issues/Bugs: http://github.com/schwern/perl5i/issues IRC: irc.perl.org on the #perl5i channel Mailing List: http://groups.google.com/group/perl5i/
Frequently Asked Questions about perl5i: perl5ifaq
Some modules with similar purposes include: Modern::Perl, Common::Sense
For a complete object declaration system, see Moose and MooseX::Declare.
1 POD Error
The following errors were encountered while parsing the POD:
Non-ASCII character seen before =encoding in 'MËTÁŁ");'. Assuming UTF-8
To install perl5i, copy and paste the appropriate command in to your terminal.
cpanm
cpanm perl5i
CPAN shell
perl -MCPAN -e shell install perl5i
For more information on module installation, please visit the detailed CPAN module installation guide.