Functions

"does($scalar, $role)"

Checks if a scalar is capable of performing the given role. The following (case-sensitive) roles are predefined:

does($role)

Called with a single argument, tests $_. Yes, this works with lexical $_.

  given ($object) {
     when(does ARRAY)  { ... }
     when(does HASH)   { ... }
  }
    

Note: in Scalar::Does 0.007 and below the single-argument form of "does" returned a curried coderef. This was changed in Scalar::Does 0.008.

"overloads($scalar, $role)"

A function "overloads" (which just checks overloading) is also available.

overloads($role)

Called with a single argument, tests $_. Yes, this works with lexical $_.

Note: in Scalar::Does 0.007 and below the single-argument form of "overloads" returned a curried coderef. This was changed in Scalar::Does 0.008.

blessed($scalar), reftype($scalar), looks_like_number($scalar)

For convenience, this module can also re-export these functions from Scalar::Util. "looks_like_number" is generally more useful than "does($scalar, q[0+])".

"make_role $name, where { BLOCK }"

Returns an anonymous role object which can be used as a parameter to "does". The block is arbitrary code which should check whether $_[0] does the role.

"where { BLOCK }"

Syntactic sugar for "make_role". Compatible with the "where" function from Moose::Util::TypeConstraints, so don't worry about conflicts.

Constants

The following constants may be exported for convenience:

"SCALAR"

"ARRAY"

"HASH"

"CODE"

"GLOB"

"REF"

"LVALUE"

"IO"

"VSTRING"

"FORMAT"

"REGEXP"

"BOOLEAN"

"STRING"

"NUMBER"

"SMARTMATCH"

Export

By default, only "does" is exported. This module uses Exporter::Tiny, so functions can be renamed:

  use Scalar::Does does => { -as => 'performs_role' };

Scalar::Does also plays some tricks with namespace::clean to ensure that any functions it exports to your namespace are cleaned up when you're finished with them. This ensures that if you're writing object-oriented code "does" and "overloads" will not be left hanging around as methods of your classes. Moose::Object provides a "does" method, and you should be able to use Scalar::Does without interfering with that.

You can import the constants (plus "does") using:

  use Scalar::Does -constants;

The "make_role" and "where" functions can be exported like this:

  use Scalar::Does -make;

Or list specific functions/constants that you wish to import:

  use Scalar::Does qw( does ARRAY HASH STRING NUMBER );

Custom Role Checks

  use Scalar::Does
    custom => { -as => 'does_array', -role => 'ARRAY' },
    custom => { -as => 'does_hash',  -role => 'HASH'  };
  
  does_array($thing);
  does_hash($thing);

Relationship to Moose roles

Scalar::Does is not dependent on Moose, and its role-checking is not specific to Moose's idea of roles, but it does work well with Moose roles.

Moose::Object overrides "DOES", so Moose objects and Moose roles should "just work" with Scalar::Does.

  {
    package Transport;
    use Moose::Role;
  }
  
  {
    package Train;
    use Moose;
    with qw(Transport);
  }
  
  my $thomas = Train->new;
  does($thomas, 'Train');          # true
  does($thomas, 'Transport');      # true
  does($thomas, Transport->meta);  # not yet supported!

Mouse::Object should be compatible enough to work as well.

See also: Moose::Role, Moose::Object, UNIVERSAL.

Relationship to Moose type constraints

Moose::Meta::TypeConstraint objects, plus the constants exported by MooseX::Types libraries all provide a "check" method, so again, should "just work" with Scalar::Does. Type constraint strings are not supported however.

  use Moose::Util::TypeConstraints qw(find_type_constraint);
  use MooseX::Types qw(Int);
  use Scalar::Does qw(does);
  
  my $int = find_type_constraint("Int");
  
  does( "123", $int );     # true
  does( "123", Int );      # true
  does( "123", "Int" );    # false

Mouse::Meta::TypeConstraints and MouseX::Types should be compatible enough to work as well.

See also: Moose::Meta::TypeConstraint, Moose::Util::TypeConstraints, MooseX::Types, Scalar::Does::MooseTypes.

Relationship to Type::Tiny type constraints

Types built with Type::Tiny and Type::Library can be used exactly as Moose type constraint objects above.

  use Types::Standard qw(Int);
  use Scalar::Does qw(does);
  
  does(123, Int);   # true

In fact, Type::Tiny and related libraries are used extensively in the internals of Scalar::Does 0.200+.

See also: Type::Tiny, Types::Standard.

Relationship to Role::Tiny and Moo roles

Roles using Role::Tiny 1.002000 and above provide a "DOES" method, so should work with Scalar::Does just like Moose roles. Prior to that release, Role::Tiny did not provide "DOES".

Moo's role system is based on Role::Tiny.

See also: Role::Tiny, Moo::Role.