Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
MooseX::Method::SignatUser(Contributed Perl DocumMooseX::Method::Signatures(3)

       MooseX::Method::Signatures - (DEPRECATED) Method	declarations with type
       constraints and no source filter

       version 0.49

	   package Foo;

	   use Moose;
	   use MooseX::Method::Signatures;

	   method morning (Str $name) {
	       $self->say("Good	morning	${name}!");

	   method hello	(Str :$who, Int	:$age where { $_ > 0 })	{
	       $self->say("Hello ${who}, I am ${age} years old!");

	   method greet	(Str $name, Bool :$excited = 0)	{
	       if ($excited) {
		   $self->say("GREETINGS ${name}!");
	       else {
		   $self->say("Hi ${name}!");

	   $foo->morning('Resi');			   # This works.

	   $foo->hello(who => 'world', age => 42);	   # This too.

	   $foo->greet('Resi', excited => 1);		   # And this as well.

	   $foo->hello(who => 'world', age => 'fortytwo'); # This doesn't.

	   $foo->hello(who => 'world', age => -23);	   # This neither.

	   $foo->morning;				   # Won't work.

	   $foo->greet;					   # Will fail.

       Provides	a proper method	keyword, like "sub" but	specifically for
       making methods and validating their arguments against Moose type

       Warning:	MooseX::Method::Signatures and MooseX::Declare are based on
       Devel::Declare, a giant bag of crack originally implemented by mst with
       the goal	of upsetting the perl core developers so much by its very
       existence that they implemented proper keyword handling in the core.

       As of perl5 version 14, this goal has been achieved, and	modules	such
       as Devel::CallParser, Function::Parameters, and Keyword::Simple provide
       mechanisms to mangle perl syntax	that don't require hallucinogenic
       drugs to	interpret the error messages they produce.

       If you want to use declarative syntax in	new code, please for the love
       of kittens get yourself a recent	perl and look at Moops and core
       signatures instead.

       The signature syntax is heavily based on	Perl 6.	However	not the	full
       Perl 6 signature	syntax is supported yet	and some of it never will be.

   Type	Constraints
	   method foo (		    $affe) # no	type checking
	   method bar (Animal	    $affe) # $affe->isa('Animal')
	   method baz (Animal|Human $affe) # $affe->isa('Animal') || $affe->isa('Human')

   Positional vs. Named
	   method foo (	$a,  $b,  $c) #	positional
	   method bar (:$a, :$b, :$c) #	named
	   method baz (	$a,  $b, :$c) #	combined

   Required vs.	Optional
	   method foo ($a , $b!, :$c!, :$d!) # required
	   method bar ($a?, $b?, :$c , :$d?) # optional

	   method foo ($a = 42)	# defaults to 42

	   method foo ($foo where { $_ % 2 == 0	}) # only even

	   method foo (	       $moo) # invocant	is called $self	and is required
	   method bar ($self:  $moo) # same, but explicit
	   method baz ($class: $moo) # invocant	is called $class

	   method foo (:     $affe ) # called as $obj->foo(affe	=> $value)
	   method bar (:apan($affe)) # called as $obj->foo(apan	=> $value)

	   method foo (Affe $bar does trait)
	   method foo (Affe $bar is trait)

       The only	currently supported trait is "coerce", which will attempt to
       coerce the value	provided if it doesn't satisfy the requirements	of the
       type constraint.

	   method foo ($bar, $,	$baz)

       Sometimes you don't care	about some parameters you're being called
       with. Just put the bare sigil instead of	a full variable	name into the
       signature to avoid an extra lexical variable to be created.

   Complex Example
	   method foo (	SomeClass $thing where { $_->can('stuff') }:
			Str  $bar  = "apan",
			Int :$baz! = 42	where {	$_ % 2 == 0 } where { $_ > 10 }	)

	   # the invocant is called $thing, must be an instance	of SomeClass and
		  has to implement a 'stuff' method
	   # $bar is positional, required, must	be a string and	defaults to "apan"
	   # $baz is named, required, must be an integer, defaults to 42 and needs
	   #	  to be	even and greater than 10

       This module is as stable	now, but this is not to	say that it is
       entirely	bug free. If you notice	any odd	behaviour (messages not	being
       as good as they could for example) then please raise a bug.

   Fancy signatures
       Parse::Method::Signatures is used to parse the signatures. However,
       some signatures that can	be parsed by it	aren't supported by this
       module (yet).

   No source filter
       While this module does rely on the hairy	black magic of Devel::Declare
       it does not depend on a source filter. As such, it doesn't try to parse
       and rewrite your	source code and	there should be	no weird side effects.

       Devel::Declare only effects compilation.	After that, it's a normal
       subroutine.  As such, for all that hairy	magic, this module is
       surprisingly stable.

   What	about regular subroutines?
       Devel::Declare cannot yet change	the way	"sub" behaves. However,	the
       signatures module can. Right now	it only	provides very basic
       signatures, but it's extendable enough that plugging
       MooseX::Method::Signatures signatures into that should be quite

   What	about the return value?
       Type constraints	for return values can be declared using

	 method	foo (Int $x, Str $y) returns (Bool) { ... }

       however,	this feature only works	with scalar return values and is still
       considered to be	experimental.

   Interaction with Moose::Role
       Methods not seen	by a role's "requires"

       Because the processing of the MooseX::Method::Signatures	"method" and
       the Moose "with"	keywords are both done at runtime, it can happen that
       a role will require a method before it is declared (which will cause
       Moose to	complain very loudly and abort the program).

       For example, the	following will not work:

	   # in	file

	   package Canine;

	   use Moose;
	   use MooseX::Method::Signatures;

	   with	'Watchdog';

	   method bark { print "Woof!\n"; }


	   # in	file

	   package Watchdog;

	   use Moose::Role;

	   requires 'bark';  # will assert! evaluated before 'method' is processed

	   sub warn_intruder {
	       my $self	= shift;
	       my $intruder = shift;

	       $self->bark until $intruder->gone;


       A workaround for	this problem is	to use "with" only after the methods
       have been defined.  To take our previous	example, Canine	could be
       reworked	thus:

	   package Canine;

	   use Moose;
	   use MooseX::Method::Signatures;

	   method bark { print "Woof!\n"; }

	   with	'Watchdog';


       A better	solution is to use MooseX::Declare instead of plain
       MooseX::Method::Signatures. It defers application of roles until	the
       end of the class	definition. With it, our example would becomes:

	   # in	file

	   use MooseX::Declare;

	   class Canine	with Watchdog {
	       method bark { print "Woof!\n"; }


	   # in	file

	   use MooseX::Declare;

	   role	Watchdog {
	       requires	'bark';

	       method warn_intruder ( $intruder	) {
		   $self->bark until $intruder->gone;


       Subroutine redefined warnings

       When composing a	Moose::Role into a class that uses
       MooseX::Method::Signatures, you may get a "Subroutine redefined"
       warning.	This happens when both the role	and the	class define a
       method/subroutine of the	same name. (The	way roles work,	the one
       defined in the class takes precedence.) To eliminate this warning, make
       sure that your "with" declaration happens after any method/subroutine
       declarations that may have the same name	as a method/subroutine within
       a role.

       o   MooseX::Declare

       o   Method::Signatures::Simple

       o   Method::Signatures

       o   Devel::Declare

       o   Parse::Method::Signatures

       o   Moose

       o   signatures

       Bugs may	be submitted through the RT bug	tracker
       Signatures> (or	<mailto:bug->).

       There is	also a mailing list available for users	of this	distribution,
       at <>.

       There is	also an	irc channel available for users	of this	distribution,
       at irc://

       I am also usually active	on irc,	as 'ether' at "".

       Florian Ragwitz <>

       o   Karen Etheridge <>

       o   Ash Berlin <>

       o   Daniel Ruoso	<>

       o   Justin Hunter <>

       o   Nicholas Perez <>

       o   Dagfinn Ilmari Mannsaaker <>

       o   Rhesa Rozendaal <>

       o   Yanick Champoux <>

       o   Cory	Watson <>

       o   Kent	Fredric	<>

       o   Lukas Mai <>

       o   Matt	Kraai <>

       o   Jonathan Scott Duff <>

       o   Jesse Luehrs	<>

       o   Hakim Cassimally <>

       o   Dave	Rolsky <>

       o   Ricardo SIGNES <>

       o   Sebastian Willert <>

       o   Steffen Schwigon <>

       This software is	copyright (c) 2008 by Florian Ragwitz.

       This is free software; you can redistribute it and/or modify it under
       the same	terms as the Perl 5 programming	language system	itself.

perl v5.24.1			  2015-10-07	 MooseX::Method::Signatures(3)


Want to link to this manual page? Use this URL:

home | help