Use Moops to create a customized Perl environment with your own syntax extensions.

1. flickr: philip66
Make your own Perl
with
M o o p s
@friedo
Mike Friedman
London Perl Workshop 2014

2. A brief history…

3. A brief history…
In the Beginning,
Perl 5
was already extensible.

4. use Foo qw(bar);

5. use Foo qw(bar);
BEGIN {!
require Foo;!
Foo->import( ‘bar’ );!
};

6. How does
!
import!
!
actually work?

7. sub import {!
my $pkg = shift;!
...
a typical import sub

8. sub import {!
my $pkg = shift;!
my $callpkg = caller;!
...
a typical import sub

9. sub import {!
my $pkg = shift;!
my $callpkg = caller;!
my @imports = @_;!
...
a typical import sub

10. sub import {!
... !
foreach !
my $sym(@imports) {!
*{"${callpkg}::$sym"}
= *{"${pkg}::$sym"}
a typical import sub

11. (many details omitted.)

12. A brief history…
import is compile-time.

13. A brief history…
import is compile-time.
1. add functions.
2. pretend they’re keywords.

14. package Adder;!
!
sub import { ... }!
sub add2 { !
return shift + 2;!
}
a pretend keyword

15. package Mine;!
!
use Adder;!
!
say add2 42;
a pretend keyword

16. A brief history…
Perl 5.2
!
Prototypes

17. Make fake keywords
!
That behave like
builtins

18. (kinda)

19. sub doblock(&@) { !
my $blk = shift;!
return $blk->( @_ );!
}!
!
doblock { !
say $_ * $_ for @_;!
} ( 1, 2, 3, 4, 5 );!
a prototype pretend keyword

20. sub doblock(&) { ... }!
!
doblock { !
say "first";!
}!
!
say "second";
a prototype pretend keyword

21. sub doblock(&) { ... }!
!
doblock { !
say "first";!
}!
!
say "second";
a prototype pretend keyword
# Fail :(

22. Prototype subs only
work as expressions.
!
Not statements.

23. sub doblock($&) { ... }!
!
doblock name { !
say "first";!
}!
!
a prototype pretend keyword
# Fail :(

24. a prototype pretend keyword
# We have to say:

25. !
!
doblock name => sub { !
say "first";!
};!
!
a prototype pretend keyword
# We have to say:

26. "&" prototypes are only
magical if they're first.

27. A brief history…
Perl 5.8
!
Devel::Declare

28. The first real way to add
!
new syntax.

29. use MooseX::Declare;!
!
class Foo { !
method bar { ... }!
...!
}!
!
a parser magic keyword

30. Devel::Declare is
complicated

31. Devel::Declare is
complicated
•Declarators?

32. Devel::Declare is
complicated
•Declarators?
•Scope injectors?

33. Devel::Declare is
complicated
•Declarators?
•Scope injectors?
•Method shadowing?

34. Devel::Declare is
complicated
•Declarators?
•Scope injectors?
•Method shadowing?
•WTF?

35. MooseX::Declare is
big, slow, and difficult to
extend.

36. A brief history…
Perl 5.12
!
The keyword API

37. Real keyword interface
in the
Perl core API.

38. package My::Keyword;!
use Keyword::Simple;!
!
sub import { !
Keyword::Simple::define( !
class => sub { !
munge_code( $$_[0] );!
}!
);!
a real custom keyword

39. So...
!
what is
!
M o o p s ?

40. use Moops;!
role NamedThing {!
has name => !
(is => "ro", isa => Str);!
}!
!
class Person with NamedThing;!
...
a Moops-defined class

41. So it's like
MooseX::Declare
?

42. Not exactly.

43. Not exactly.
•Moo by default, but can use Moose

44. Not exactly.
•Moo by default, but can use Moose
•Uses Keyword::Simple for new syntax.

45. Not exactly.
•Moo by default, but can use Moose
•Uses Keyword::Simple for new syntax.
•Uses Kavorka for functions/methods

46. Not exactly.
•Moo by default, but can use Moose
•Uses Keyword::Simple for new syntax.
•Uses Kavorka for functions/methods
•Designed for easy extensibility

47. A brief history…
One year ago,
!
I did this:

48. I like imports

49. I hate boilerplate

50. package MyApp::Setup;!
use Import::Into;!
!
use List::Util ();!
use List::MoreUtils ();!
use Scalar::Util ();!
use Const::Fast ();!
use Try::Tiny ();!
use Data::Alias ();!
use autodie ();!
...
Custom setup class

51. !
!
sub import { !
my $callpkg = caller;!
Scalar::Util->import::into(!
$callpkg, 'blessed', 'refaddr'!
);!
List::Util->import::into(!
$callpkg, 'reduce', 'all', ...!
);!
...!
}
Custom setup class

52. Works pretty great!

53. Unless I want to use
custom syntax

54. use MooseX::Declare; !
# (or Moops)!
!
class MyApp::Thing { !
use MyApp::Setup;!
}!
!
# :/!
Custom setup class

55. I have to use the Setup
class from within
the right namespace.

56. What if the Setup class
could also inject custom
syntax?

57. package MyApp::Setup;!
use parent 'Moops';!
sub import { !
my $pkg = shift;!
my @imports = (!
'List::Util' => ['any'],!
'Scalar::Util' => ['blessed'],!
'experimental' => ['postderef']!
...!
);!
}
Moops-based setup class

58. sub import {!
...!
$pkg->SUPER::import(!
imports => @imports!
);!
}!
!
!
# :D
Moops-based setup class

59. Cool!

60. flickr: philip66
Questions
@friedo
Mike Friedman
London Perl Workshop 2014