TITLE

SUBTITLE

I<Warning>: this role is part of the Rakudo implementation, and is not
a part of the language specification.


Classes, roles and grammars can have attributes. Storage and introspection of
attributes is implemented by this role.


head

Adds an attribute. C<$attribute> must be an object that supports the
methods C<name>,  C<type> and C<package>, which are called without arguments.
It can for example be of L<type Attribute|/type/Attribute>.


Returns a list of attributes. For most Raku types, these will be objects of
L<type Attribute|/type/Attribute>.


Marks a type whose attributes default to having a write accessor. For example
in


class Point is rw {
    has $.x;
    has $.y;
}


The C<is rw> trait on the class calls the C<set_rw> method on the metaclass,
making all the attributes implicitly writable, so that you can write;


code

=begin code :preamble<class Point {}>
my $p = Point.new(x => 1, y => 2);
$p.x = 42;
=end code


Returns a true value if L<method set_rw|#method set_rw> has been called on
this object, that is, if new public attributes are writable by default.


comment

=begin comment

TODO: compose_attributes, get_attribute_for_usage

Also TODO: describe :local, :excl, :all options of method attributes

=end comment


root

Metaobject that supports the C3 method resolution order


role Metamodel::C3MRO


Metarole for documenting types.


role Metamodel::Documenting


Metaobject supporting object finalization


role Metamodel::Finalization


Metaobject that supports storing and introspecting methods


role Metamodel::MethodContainer


Metaobject for generating mixins


role Metamodel::Mixins


Metaobject that supports resolving inherited methods


role Metamodel::MROBasedMethodDispatch


Metaobject that supports multiple inheritance


role Metamodel::MultipleInheritance


Metaobject that supports named types


role Metamodel::Naming


Represents a group of roles with different parameterizations


role Metamodel::ParametricRoleGroupHOW


Represents a non-instantiated, parameterized, role.


role Metamodel::ParametricRoleHOW


Metaobject that supports private methods


role Metamodel::PrivateMethodContainer


Metaobject that supports holding/containing roles


role Metamodel::RoleContainer


Metaobject that supports punning of roles.


role Metamodel::RolePunning


Metarole for type stashes


role Metamodel::Stashing


Metaobject that supports trust relations between types


role Metamodel::Trusting


Metaobjects that support versioning


role Metamodel::Versioning


Metaobject that can hold attributes


para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

role Metamodel::AttributeContainer


L<Metamodel|/language/mop> role for the
L<I<C3> method resolution order (MRO)|https://en.wikipedia.org/wiki/C3_linearization>.
I<Note>: this method,
along with almost the whole metamodel, is part of the Rakudo implementation.


The I<method resolution order> for a type is a flat list of types including the
type itself, and (recursively) all super classes. It determines in which order
the types will be visited for determining which method to call with a given
name, or for finding the next method in a chain with
L<nextsame|/language/functions#sub_nextsame>,
L<callsame|/language/functions#sub_callsame>,
L<nextwith|/language/functions#sub_nextwith> or
L<callwith|/language/functions#sub_callwith>.


=begin code
class CommonAncestor { };   # implicitly inherits from Any
class Child1 is CommonAncestor { }
class Child2 is CommonAncestor { }
class GrandChild2 is Child2 { }
class Weird is Child1 is GrandChild2 { };

say Weird.^mro; # OUTPUT: «(Weird) (Child1) (GrandChild2) (Child2) (CommonAncestor) (Any) (Mu)␤»
=end code


C3 is the default resolution order for classes and grammars in Raku.
Note that roles generally do not appear in the method resolution order (unless
they are punned into a class, from which another type inherits), because
methods are copied into classes at role application time.


Returns a list of types in the method resolution order, even those that are
marked C<is hidden>.


say Int.^mro;   # OUTPUT: «((Int) (Cool) (Any) (Mu))␤»


Returns a list of types in method resolution order, excluding those that are
marked with C<is hidden>.


class Match is Capture is Cool does NQPMatchRole {}


C<Match> objects are the result of a successful regex match, including
any zero-width match. They store a reference to the original string (C<.orig>),
positional and named captures, the positions of the start and end of the match
in the original string, and a payload referred to as I<AST> (abstract syntax
tree), which can be used to build data structures from complex regexes and
grammars.


The last match is also stored in the X<C<$¢>|Variables,$¢> C<Match> object, which is
lexically scoped to the regex, that is, only available from within the regular
expression, as shown here:


my $c;
'abc' ~~ /.$${ $c = $¢ }/;
say $c; # OUTPUT: «｢c｣␤»


In this example we are running the code among curly braces when the match
occurs,
in this case the last letter in the string (actually, the last, indicated by the
double C<$>, character); C<$c> gets the value of the cursor C<$¢>, which
contains the C<Match>; when used with C<say>, the C<Match> is stringified by
calling C<.Str> on it. This C<$¢> offers a way of capturing the Match inside a
regular expression; outside, you need to use L<C<$/>|/syntax/$$SOLIDUS>


my $c; 'camelia' ~~ /<[ l m ]> {$c = $¢}/;
say $c; # OUTPUT: «｢m｣␤»
say $/; # OUTPUT: «｢m｣␤»


B<Note>: This feature works only from Raku version 2018.02. It would have
returned L<C<Nil>|/type/Nil> with any previous version. Alternatively and prior to that
version, you could use C<$/> which, inside the regex, has the same value:


'123' ~~ / (\d) { say $0; say $/; } \d+ /; # OUTPUT: «｢1｣␤｢1｣␤ 0 => ｢1｣␤»


The main difference between C<$/> and C<$¢> is scope: the latter only has a
value inside the regex:


=begin code
'123' ~~ / (\d) { say $/; say $¢; } \d+ /; # OUTPUT: «｢1｣␤ 0 => ｢1｣␤｢1｣␤ 0 => ｢1｣␤»
say "¢ → ", $¢, "/ is $/"; ; # OUTPUT: «¢ → Nil/ is 123␤»
=end code


Submatches are also C<Match> objects (or lists of C<Match> objects,
if the corresponding regex was quantified), so each match object
can be seen as the root of a tree of match objects.


A C<Match> object can also hold the result of a match in progress
(while the grammar engine is running), in which case the C<pos> method
returns the current position. This view on C<Match> objects is only visible
if you call code from within a regex.


B<Note (deprecated)>: There is a synonym for this class, X<C<Cursor>|Reference,Cursor>,
 defined as:


Initially, it was used to keep track of initial position in regex matches. In
current versions, it's an alias for C<Match>.


Returns the current position as a string index into C<Match.target> for a regex match
I<in progress>:


my $a = 'abcdef';
$a ~~ /b. {say $/.pos }../;     # OUTPUT: «3␤»


You should not use this method on a finished C<Match>, as the output can be
implementation specific or is, in any case, unspecified.


Returns a string representation of the object against which the regex matches. This is the value that the regex engine works with internally.


my $a = "þor" ~~ /o/;
say $a.target # OUTPUT: «þor␤»


Returns the numbers of characters in the matched string or 0 if there's been
no match.


Returns the original input to the regex engine, which is usually a string,
but doesn't need to be (could be anything that can be coerced to a string):


42 ~~ /.+/;
say $/.orig;            # OUTPUT: «42␤»
say $/.orig.^name;      # OUTPUT: «Int␤»


See L<method target|#method target> for a close equivalent that always returns a string.


Returns the index of the starting position of the match.


Returns the index of the position next to the end of the match. It will
return the match position if the end of the match is negative, and L<C<Nil>|/type/Nil> if
there has been no match.


Returns the payload that was set with L<C<make>|/routine/make>.


method make(Match:D: Mu $payload)
sub make(Mu $payload)


Sets the C<.ast> attribute, which will be retrieved using C<.made>.


Member variable


class Attribute


Removal of a task from a Scheduler before normal completion


class Cancellation


Thread-safe queue for sending values from producers to consumers


class Channel


CompUnit


class CompUnit


CompUnit::Repository::FileSystem


class CompUnit::Repository::FileSystem


CompUnit::Repository::Installation


role Metamodel::AttributeContainer

Methods

method add_attribute

method attributes

method set_rw

method rw

See Also