The Bash "PATH" environment variable contains a colon-separated list of paths. pathed - "path editor" - can split the path, append, prepend or remove elements, remove duplicates and reassemble it.
]]>Do you know of a better way of building the data structure with the given regex/grammar?
(I'm aware of Parse::RecDescent and Regexp::Grammars, but wanted to do this as simply as possible.)
#!/usr/bin/env perl
# Exercising perl 5.10 regular expression features:
# Return a tree structure while matching simple Lisp-like constructs
use warnings;
use strict;
use 5.010;
use Test::More;
use Test::Differences;
sub parse {
my $string = shift;
# 'my @S' produces 'Variable "@S" will not stay shared' and failures
our @S = ();
# 'my @t' produces 'Can't localize lexical variable @t'
our @t;
# Use a stack because I can't see a way of localizing variables when
# recursing into subpatterns.
state $re = qr{
(?&tree)
(?(DEFINE)
(?<tree>
\(
(?{push @S, 'MARK'})
(?&element) (?: \s+ (?&element) )*
\)
(?{
local @t;
while ((my $el = pop @S) ne 'MARK') { unshift @t, $el }
push @S, \@t;
})
)
(?<element> (?&value) | (?&tree) )
(?<value> (\w+) (?{ push @S, $^N }) )
)
}x;
$string =~ $re;
pop @S;
}
sub check {
my ($string, $expect) = @_;
eq_or_diff parse($string), $expect, $string;
}
check('(print)', ['print']);
check('(print foo bar baz)', [qw(print foo bar baz)]);
check('(print (foo 1 2) (bar 3 (baz 4 5)))',
[ 'print', [ 'foo', '1', '2' ], [ 'bar', '3', [ 'baz', '4', '5' ] ] ]);
check('((foo (bar 1)) baz)', [ [ 'foo', [ 'bar', '1' ] ], 'baz' ]);
done_testing;
You can get the code at https://gist.github.com/1257636 .
]]>I still program Perl for a living, and it'd be nice to see Perl friends, for example, in Frankfurt next year.
About all those CPAN modules - I've looked over the 100+ dists that are under my name on CPAN and have found that most of these I neither use anymore nor do I have any wish to maintain them. Most of them were related to an older work project and are probably not used outside of that.
There are only about six or so dists that I'm really using and maintaining. There are a few modules that others have expressed an interest in maintaining - mostly the Dist::Zilla plugins - and I've given them co-maint.
So, it's no big deal; just curbing my "social" presence.
(Actually, let's see about that Twitter account - as far as I can tell, you can still re-activate it within 30 days, so maybe the addiction might win... :) )
]]>$dbh->prepare(). Here is a simple dip script to do that.
dip -e 'before { warn ARGS(1) } call qr/DBI::.*::prepare/' foo.pl
So I have to change the package name, but I've long felt that this can be automated - after all, if the module file is lib/Foo/Bar.pm, vim should be able to deduce that this is package Foo::Bar and change the package name accordingly.
The script below does that; it makes a few assumptions: that your modules live in a lib/ directory; that the package line already exists (but presumably with the wrong name) and that the package name to be replaced is in the first line that starts with 'package', followed by the name.
It's simple enough so you can adapt it to your needs. I hope you find this useful!
nnoremap <Leader>pa :<C-u>call PerlReplacePackageName()<CR>
function! PerlPackageNameFromFile()
let filename = expand('%:p')
let package = substitute(filename, '^.*/lib/', '', '')
let package = substitute(package, '\.pm$', '', '')
let package = substitute(package, '/', '::', 'g')
return package
endfunction
function! PerlReplacePackageName()
let package = PerlPackageNameFromFile()
let pos = getpos('.')
1,/^package\s/s/^package\s\+\zs[A-Za-z_0-9:]\+\ze\(\s\+{\|;\)/\=package/
call setpos('.', pos)
endfunction
Thanks to kana1 for his corrections!
]]>The Perl 5 Core Maintenance Fund aims to raise $25.000 to to pay for Nicholas Clark and Dave Mitchell to work for 3 months on the Perl 5 core, fixing bugs and making other improvements.
Vienna.pm decided to set aside $10.000 as "match funding" - ie for every $1 that someone else donates, Vienna.pm donate $1, until $10,000 + $10,000 is raised, and only 20% remains to reach the target. The hope is that "match funding" will encourage people to donate a bit more themselves than a simple unconditional donation.
]]>$ dip -e 'aspect Profiled => call qr/^Person::set_/' myapp.pl
$ dip -s toolkit/count_new.dip -- -S myapp.pl
$ dip -e 'before { count("constructor", ARGS(1), ustack(5)); $c{total}++ }
call qr/URI::new$/' test.pl
$ cat quant-requests.dip
# quantize request handling time, separated by request URI
before { $ts_start = [gettimeofday] }
call qr/Dancer::Handler::handle_request/;
after { quantize ARGS(1)->request_uri => 10**6*tv_interval($ts_start) }
call qr/Dancer::Handler::handle_request/;
$ dip -s request-quant.dip test.pl
...
/
value ------------------ Distribution ------------------ count
1024 | 0
2048 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ 95
4096 |@@ 4
8192 | 0
16384 |@ 1
32768 | 0
/login
value ------------------ Distribution ------------------ count
512 | 0
1024 |@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ 70
2048 |@@@@@@@@@@@@@@@ 30
4096 | 0
dip is a dynamic instrumentation framework for troubleshooting Perl
programs in real time. dip can provide fine-grained information,
such as a log of the arguments with which a specific function is being
called.
Conceptually, dip sits on top of Aspect and uses pointcuts and
advice - to use Aspect-oriented programming jargon - to define dynamic
instrumentation. These instruments are applied to the program from the
outside, without having to change the program code at all. While most
dip scripts will consist of aspect-oriented instrumentation, they
can also use the full power of Perl.
dip aims to bring some of the power of DTrace to perl. Therefore it
is useful to stick to DTrace terminology. dip pointcuts resemble
DTrace "probes"; dip advice resembles DTrace "actions".
Whenever the condition for a probe is met, the associated action is executed; the probe "fires". A typical probe might fire when a certain function is entered or exited. The probe's action may analyze the run-time situation by accessing the call stack and context variables and evaluating expressions; it can then print out or log some information, record it in a database, or modify variables - an action is, after all, pure Perl code. Using variables allows probes to pass information to each other, allowing them to cooperatively analyze the correlation of different events. For example, a probe that fires when a function is entered could record the current time; another probe that fires when that function is exited could record how much time the function took.
Because of the nature of Aspect-oriented programming in Perl, you only pay for what you use. When probes are defined, all existing possible locations for running the action are examined, and the probe is only activated for those locations that match the probe's condition.
At the end of your program run, during END time, all aggregators -
see below - will dump their results. Also any other hashes you have
written to in your dip scripts will be dumped.
For example, if you simply wanted to know which kinds of objects have been instantiated at least once, you could use:
before { $c{total}++ } call qr/::new$/
and then %c will be dumped.
dip provides aggregating functions that help in understanding a set
of data. You can keep counts of occurrences, or quantize data, much
like with DTrace.
The quantize aggregating function generates a power-of-two
distribution - see its documentation.
Remembers the dip script given on the command-line so we can run it in
instrument(). Complains if there was no dip script. The --delay
option is passed in this way as well.
Evaluates the dip script we remembered in import(). Dies if there
was a problem evaluating it.
Normally this function will be called automatically during INIT
time, but you can delay by giving the --delay option to dip; you
would use this if your program loads other code at runtime - using
do(), for example - that needs to be instrumented as well. In that
case you have manually activate the instrumentation using:
$dip::dip && $dip::dip->();
Convenience function that takes a filename and runs the file via
do(). This is what dip -s uses. For example:
dip -s myscript.dip myapp.pl
is turned into:
dip -e 'run q!$file!' myapp.pl
and ultimately
perl -Mdip='run q!$file!' myapp.pl
Returns a concise stack trace. Takes an argument of how many levels
deep the stack trace should be; the default is 20 levels. Stack frames
that point to a package name in the Aspect:: or dip namespace
are omitted.
Example: count how many times a XML::LibXML::NodeList object is
created, and keep a separate counter for each place it is created
from, remembering three stack frames for each place:
before { count "constructor", ARGS(0), ustack(3) }
call qr/XML::LibXML::NodeList::new$/
Returns what Carp's cluck() would return, again with Aspect::
and dip namespaces omitted.
This aggregator function takes a counter name and a value and keeps a count of how often this value was seen for this counter.
You can pass several values; they will be concatenated using newlines.
See the example for ustack().
Example: For each class, count how many objects are created. Also keep a total count.
before { count("constructor", ARGS(0)); $c{total}++ }
call qr/::new$/
Convenience method to dump a variable like Data::Dumper does.
Example: Show all requests a Dancer web application handles:
before { dump_var ARGS(1) }
call qr/Dancer::Handler::handle_request/
Convenience function to right-trim a string.
Convenience function that, if given a string - for example, a package name -, just returns the string, but if given an object, it returns that object's class.
Useful if objects you want to instrument are sometimes created by
calling new() on existing objects:
before { count("constructor", rref ARGS(0)) } call qr/::new$/
Convenience function to access the arguments of a function that
you are instrumenting. ARGS(0), for example, returns the first
argument. You can use several argument indices; in this case the
indicated function arguments will be stringified and concatenated with
a space.
ARGS(0) is equivalent to $_->{args}[0]; ARGS(1,2) is equivalent to
join ' ' => ARGS(0), ARGS(1) - see Aspect for the kind of context information that is passed to advice code.
This aggregator function takes a name, or an reference to a list of names, and a value. For each name, it keeps track of a power-of-two frequency distribution of the values of the specified expressions. Increments the value in the highest power-of-two bucket that is less than the specified expression.
]]>It was a very enjoyable event - good company, good code, good beer. Thanks to Philippe Bruhat (BooK) for organizing it; to Booking.com for their offices and sponsorship; and to Vienna.pm for their sponsorship, which also helped to cover my travel and accommodation costs.
]]>each() - as well as keys() and values() - works on arrays,
where previously these functions were restricted to hashes. When iterating over
an array, each() returns both the index and the value.
my @x = 50..59;
while(my ($i, $v) = each @x) {
say "index $i, value $v";
}
will print:
index 0, value 50
index 1, value 51
index 2, value 52
index 3, value 53
index 4, value 54
index 5, value 55
index 6, value 56
index 7, value 57
index 8, value 58
index 9, value 59
Previously you could iterate over the array values but had to keep a counter yourself, or you could have a for-loop counting up, but then you had to retrieve the current array element separately. So this new construct saves quite a bit of code.
On a related note, if you need to iterate over an array, taking several elements at a time, you can use the well-known idiom:
while (my ($f, $g) = splice @x, 0, 2) {
say "f $f, g $g";
}
which will print:
f 50, g 51
f 52, g 53
f 54, g 55
f 56, g 57
f 58, g 59
state variable or an our variable.
sub foo {
# ...
state $some_value //= ... some computation ...;
# ...
}
Using the defined-or operator, the value will only be computed the first time the subroutine is called.
But what if the computation takes several statements? You could move it to its own subroutine and call it with a single statement, or you might resort to something like:
# NOT IDIOMATIC
sub foo {
# ...
state $some_value;
unless (defined $some_value) {
# ... some more ...
# ... intensive ...
# ... computation ...
$some_value = ...;
}
# ...
}
The problem is that we need to write $some_value three times.
But a more idiomatic way is to use an anonymous subroutine and call it in-place:
sub foo {
# ...
state $some_value //= sub {
# ... some more ...
# ... intensive ...
# ... computation ...
}->();
# ...
}
~~@x ~~ ~~@y
is true if @x and @y have the same number of elements.
This rather elegant obfuscation uses the smart match operator as well as double bitwise negation.
]]>perl -nE'}{say$.' foo.txt
Let's see how perl parses this one-liner:
$ perl -MO=Deparse -nE'}{say$.' foo.txt
BEGIN {
$^H{'feature_unicode'} = q(1);
$^H{'feature_say'} = q(1);
$^H{'feature_state'} = q(1);
$^H{'feature_switch'} = q(1);
}
LINE: while (defined($_ = <ARGV>)) {
();
}
{
say $.;
}
-e syntax OK
So -E turns on the special features (we only use say here) and -n
provides the boilerplate code. As for $., perldoc perlvar says that it is
the current line number for the last filehandle accessed.
some_statement;
my $o = Some::Class->new;
do_something_with($o);
You obviously need to write use Some::Class at the top. So you either move
the cursor near the top and add the line, then jump to the previous line
number, or maybe you split the window, move to the new viewport, make the
change, then close that viewport.
There is a better way. Here is a vim function for adding a use statement to
the top of your file. I prefer it to go below my last existing use statement,
except for special cases like use strict, use constant etc. If there isn't
any such regular use statement, I want the new use statement to appear
below the ABSTRACT (a Dist::Zilla-related comment) or below the package
statement. Failing that, I want the use statement to appear below any
existing use statement. If there isn't one of those either, below the shebang
line. If we don't even have that, just put it at the top of the file.
Your aesthetic requirements may vary, so change the function accordingly.
This is my first real Vim script function that I've written, so excuse the 'baby Vim'.
" perl: add 'use' statement
"
" make sure you have
" setlocal iskeyword=48-57,_,A-Z,a-z,:
" so colons are recognized as part of a keyword
function! PerlAddUseStatement()
let s:package = input('Package? ', expand('<cword>'))
" skip if that use statement already exists
if (search('^use\s\+'.s:package, 'bnw') == 0)
" below the last use statement, except for some special cases
let s:line = search('^use\s\+\(constant\|strict\|warnings\|parent\|base\|5\)\@!','bnw')
" otherwise, below the ABSTRACT (see Dist::Zilla)
if (s:line == 0)
let s:line = search('^# ABSTRACT','bnw')
endif
" otherwise, below the package statement
if (s:line == 0)
let s:line = search('^package\s\+','bnw')
endif
" if there isn't a package statement either, put it below
" the last use statement, no matter what it is
if (s:line == 0)
let s:line = search('^use\s\+','bnw')
endif
" if there are no package or use statements, it might be a
" script; put it below the shebang line
if (s:line == 0)
let s:line = search('^#!','bnw')
endif
" if s:line still is 0, it just goes at the top
call append(s:line, 'use ' . s:package . ';')
endif
endfunction
map ,us :<C-u>call PerlAddUseStatement()<CR>
use Data::Dumper;
sub boo { 4,5,6 }
my @x = ( boo() || 5,8,7);
print Dumper \@x;
What do you think this prints?
Let's look at some simpler examples of code:
$ perl -le'@x = (4,5,6,7,8); $y = @x; print $y'
5
An array like @x, in scalar context, evaluates to the number of elements in
that array. In this case, @x contains five elements.
$ perl -le'$y = (4,5,6,7,8); print $y'
8
A list, as opposed to an array, returns the last element in scalar context - in this case, 8.
Let's see how perl parses this line. We can use the B::Deparse module with the
-p option, which adds extra parentheses to make the structure clearer.
$ perl -MO=Deparse,-p -le'$y = (4,5,6,7,8); print $y'
BEGIN { $/ = "\n"; $\ = "\n"; }
($y = ('???', '???', '???', '???', 8));
print($y);
-e syntax OK
As you can see, the unused constant values have been optimized away.
perldoc perldata says this about arrays and lists in scalar context:
If you evaluate an array in scalar context, it returns the length of the array. (Note that this is not true of lists, which return the last value, like the C comma operator, nor of built-in functions, which return whatever they feel like returning.)
And finally:
$ perl -le'$y = (4..8); print $y'
This prints an empty line. You might have thought that this is the same as the line with the list above, but the range operator is somewhat different. In list context, it does indeed return a list of values counting from the left value to the right value. However, in scalar context, the range operator behaves like a flip-flop, starting out with a false value, which stringifies to an empty string.
perldoc perlop says this about the range operator:
In scalar context, ".." returns a boolean value. The operator is bistable, like a flip-flop, and emulates the line-range (comma) operator of sed, awk, and various editors. Each ".." operator maintains its own boolean state, even across calls to a subroutine that contains it. It is false as long as its left operand is false. Once the left operand is true, the range operator stays true until the right operand is true, AFTER which the range operator becomes false again.
After this discussion, you probably know what the program at the beginning of this post prints. Let's look at how perl parses it:
$ perl -MO=Deparse,-p test.pl
use Data::Dumper;
sub boo {
(4, 5, 6);
}
(my(@x) = ((boo() || 5), 8, 7));
print(Dumper((\@x)));
test.pl syntax OK
If we run the program, it prints:
$ perl test.pl
$VAR1 = [
6,
8,
7
];
The expression (boo() || 5) is the same as ((4, 5, 6) || 5) and since a
list returns the last value in scalar context, this is the same as (6 || 5),
which is 6.