For quite some time perl provided a form of
my declarations that
includes a type name, like this:
my Str $x = 'foo';
However, that didn't do anything useful, until Vincent Pit came along
and wrote the excellent
Lexical::Types
module, which allows you to extend the semantics of typed lexicals and
actually make them do something useful. For that, it simply invokes a
callback for every
my declaration with a type in the scopes it is
loaded. Within that callback you get the variable that is being
declared as well as the name of the type used in the declaration.
We also have Moose type constraints and the great
MooseX::Types module,
that allows us to define our own type libraries and import the type
constraints into other modules.
Let's glue those modules together. Consider this code:
use MooseX::Types::Moose qw/Int/;
use Lexical::Types;
my Int $x = 42;
The first problem is that the perl compiler expects a package with the
name of the type used in
my to exist. If there's no such package
compilation will fail.
Creating top-level namespaces for all the types we want to use would
obviously suck. Luckily the compiler will also try to look for a
function with the name of the type in the current scope. If that
exists and is inlineable, it will call that function and use the
return value as a package name.
In the above code snippet an
Int function already exists. We
imported that from
MooseX::Types::Moose. Unfortunately it isn't
inlineable. Even if it were, compilation would still fail, because it
would return a
Moose::Meta::TypeConstraint instead of a valid
package name.
To fix that, let's rewrite the code to this:
use MooseX::Types::Moose qw/Int/;
use MooseX::Lexical::Types qw/Int/;
my Int $x = 42;
Let's also write a MooseX::Lexical::Types module that replaces
existing imported type exports with something that can be inlined and
returns an existing package name based on the type constraint's name.
package MooseX::Lexical::Types;
use Class::MOP;
use MooseX::Types::Util qw/has_available_type_export/;
use namespace::autoclean;
sub import
my ($class, @args) = @_;
my $caller = caller();
my $meta = Class::MOP::class_of($caller) Class::MOP::Class->initialize($caller);
for my $type_name (@args)
my $type_constraint = has_available_type_export($caller, $type_name);
my $package = 'MooseX::Lexical::Types::TYPE::' . $type_constraint->name;
Class::MOP::Class->create($package);
$meta->add_package_symbol('&'.$type_name => sub () $package );
Lexical::Types->import;
1;
With that the example code now compiles. Unfortunately it breaks every
other usecase of MooseX::Types. The export will still need to return a
Moose::Meta::TypeConstraint at run time so this will continue to
work:
has some_attribute => (is => 'ro', isa => Int);
So instead of returning a plain package name from our exported
function we will return an object that delegates all method calls to
the actual type constraint, but evaluates to our special package name
when used as a string:
my $decorator = MooseX::Lexical::Types::TypeDecorator->new($type_constraint);
$meta->add_package_symbol('&'.$type_name => sub () $decorator );
and:
package MooseX::Lexical::Types::TypeDecorator;
use Moose;
use namespace::autoclean;
extends 'MooseX::Types::TypeDecorator';
use overload '""' => sub
'MooseX::Lexical::Types::TYPE::' . $_[0]->__type_constraint->name
;
1;
Now we're able to use
Int as usual and have Lexical::Types invoke
its callback on
MooseX::Lexical::Types::TYPE::Int. Within that
callback we will need the real type constraint again, but as it is
invoked as a class method with no good way to pass in additional
arguments, we will need to store the type constraint somewhere. I
choose to simply add a method to the type class we create when
constructing our export. After that, all we need is to implement our
Lexical::Types callback. We will put that in a class all our type
classes will inherit from:
Class::MOP::Class->create(
$package => (
superclasses => ['MooseX::Lexical::Types::TypedScalar'],
methods =>
get_type_constraint => sub $type_constraint ,
,
),
);
The Lexical::Types callback will now need to tie things together by
modifying the declared variable so it will automatically validate
values against the type constraint when being assigned to. There are
several ways of doing this. Using
tie on the declared variable
would probable be the easiest thing to do. However, I decided to use
Variable::Magic
(also written by Vincent Pit - did I mention he's awesome?), because
it's mostly invisible at the perl level and also performs rather well
(not that it'd matter, given that validation itself is relatively
slow):
package MooseX::Lexical::Types::TypedScalar;
use Carp qw/confess/;
use Variable::Magic qw/wizard cast/;
use namespace::autoclean;
my $wiz = wizard
data => sub $_[1]->get_type_constraint ,
set => sub
if (defined (my $msg = $_[1]->validate($ $_[0] )))
confess $msg;
();
;
sub TYPEDSCALAR
cast $_[1], $wiz, $_[0];
();
1;
With this, our example code now works. If someone wants to assign,
say,
'foo' to the variable declared as
my Int $x our magic
callback will be invoked, try to validate the value against the type
constraint and fail loudly. WIN!
The code for all this is available
github and should also
be on CPAN shortly.
You might notice warnings about mismatching prototypes. Those are
caused by Class::MOP and fixed in the git version of it, so they'll go
away with the next release.
There's still a couple of caveats, but please see
the documentation
for that.
This year, the annual Debian conference will be held in Managua, Nicaragua. And I'll
be lucky enough to spend two weeks visiting the country after Debconf,
along with Elisabeth.
Yes, I'll arrive in Nicarague on July 2nd, spend nearly the entire
Debcamp, then Debconf, then we'll spend 16 days around the western
part of Nicaragua, trying to discover the magic of this country.
So, this post is about sharing our plans with my readers. Of course, I
do not know the country so we may have made mistakes and bad choices.
We'll see.
Immediately after Debconf, Elisabeth will join in Managua. She'll be
landing on July 15th. We'll then spend a night in an hotel near the
airport and immediately leave the day after for Matagalpa, in North
Nicaragua. We rented a car for the entire trip indeed, and will be on our own on
wild Nicaragua roads..:-)
We'll spend two nights in Matagalpa. We plan to
visit some coffee or cigar plants, probably have a trip to Lake Apanas
and Jinotega.
Then, we'll have a short road trip to Esteli where we spend again two
nights. We'll be visiting a coffee growing place (beneficio seco de
caf ). A full day visit is planned at Miraflor natural reserve to enjoy te
beauties of hundreds orchids and some local natural marvels.
The next move will be to Leon, where we'll spend 4 nights, visiting a
cigar factory (tabacaleras de puros?) on the way, as well as San
Jacinto, a place with hydrothermal sources and "Hervideros" (geysers).
Four nights in Leon leaves
plenty of time for several activities *and* enjoying the colonial
city. We'll have a full day at Juan Venado Island reserve with boat
trip from Las Penitas (on a fisherman's boat from what the travel agency mentioned),
then another full day climbing on the Cerro Negro volcano. Indeed, I
was originally considering climbing the Momotombo, but our travel
agency warned about the high difficulty. I would have loved that
myself but maybe not the two of us...and this is a trip for
both of us! So, we played the safe option..:-)
After these 4 nights in Leon, we'll move to Granada for 3 nights,
through Leon Viejo (the former site of Leon).
From Granada, one
day will there be used for a visit in the Masaya National Park and see
the beauties of Masaya volcano (this is indeed something that could be
done for Debconf day trip, IMHO, as it doesn't seem that far from
Managua). Another day will be spent to Las
Isletas on lake Nicaragua and others visiting the colonial city of
Granada. Or, of course, whatever things we don't even known about
now..:-)
Then we'll move to what I personnally consider the peak of the trip: 3
nights on Ometepe island on lake Nicaragua. Just check Wikipedia to
see why Ometepe is, in my opinion, THE place to go in Nicaragua. Here, I'll have
my volcano..:-). Indeed, Elizabeth "authorized" me to book a local
guide and then climb Concepcion Volcan, if the weather allows for it.
1600m height, that doesn' seem to be a big issue....except when
starting from a little bit above sea level and are climbing a volcano
that looks like s postcard volcano : nearly a perfect cone shape.
So, let's cross fingers for having good weather that day. I promise
myself I'll record the GPS track of that one and, even if I'll
probably be walking most of the climbing (except if I have a very
trained guide...), I'll add it to my run tracks!
We might also be going to climb Ometepe's other volcano (Maderas) the day after
so that Elizabeth also enjoys these beauties. There also seems to be
great places around Maderas such as San Ramon Cascade, Finca el
Porvenir, etc.
Then, at the end of all this, it will be time to come back to Managua
in the final day and fly back to Paris in the early morning of July 31st.
All over, I'll be in Nicaragua from July 2nd until July 31st! Full
month away, yay! Hurrah for the crazy number of holidays those lazy
French people have..:-)
During this trip, we might find it interesting some local geeks (not
too many as Elizabeth is not that deeply interested in beersigning!)
and share a few nice things in local places which are only known by
locals.
In case you're interested, out (very clever) travel agency is named
Nicaragua Adventures and they're definitely worth contacting if you
want to travel around .ni, particularly if we prefer booking things in
advance as we do. They speak Spanish (of course!), English and French.
They're very responsive to e-mail as well.
Hardly anything ruins a glorious day of coding like fat-fingering the commit message late at night as you doze off, and then pushing it out for the world to see. To prevent that, I have equipped my Emacs configuration with a few little tools now.
Also, 
There is a route from the city centre almost straight to the campus alongside the
