TITLE

SUBTITLE

A C<Stash> is a hash that is used for symbol tables at the package scoping level
in Raku.


To get a Stash, you can call the C<.WHO> pseudo-method on a package (because it
answers the question I<who lives here?>), or if you write the package name as
a literal, append two colons:


class Boring {
    class Nested { };
    our sub package_sub { }
    my sub lexical { };
    method a_method() { }
}
say Boring::.^name;             # OUTPUT: «Stash␤»
say Boring.WHO === Boring::;    # OUTPUT: «True␤»


Since it inherits from L<C<Hash>|/type/Hash>, you can use all the usual hash
functionality:


code

As the example above shows only "our"-scoped things appear in the C<Stash>
(nested classes are "our" by default, but can be excluded with "my".)  Lexicals
and methods are not included in a Stash, since they do not live in the package
table.  Lexicals live in a separate lexical pad, which is only visible from
inside the scope.  Methods (in the case that the package is also a class) have
a separate method table, and are accessible through introspection on the
class itself, via C<.can> and C<.^methods>.


root

Sequence of itemized values


class Array


Immutable collection of distinct objects with integer weights


class Bag


Mutable collection of distinct objects with integer weights


class BagHash


Argument list suitable for passing to a Signature


class Capture


Mapping from strings to itemized values


class Hash


Low level storage of positional values


class IterationBuffer


Sequence of values


class List


Immutable mapping from strings to values


class Map


Immutable collection of distinct objects with Real weights


class Mix


Mutable collection of distinct objects with Real weights


class MixHash


Codepoint string in Normal Form C (composed)


class NFC


Codepoint string in Normal Form D (decomposed)


class NFD


Codepoint string in Normal Form KC (compatibility composed)


class NFKC


Codepoint string in Normal Form KD (compatibility decomposed)


class NFKD


Key/value pair


class Pair


Stash type for pseudo-packages


class PseudoStash


Interval of ordered values


class Range


An iterable, potentially lazy sequence of values


class Seq


Immutable collection of distinct objects


class Set


Mutable collection of distinct objects


class SetHash


A kind of List that automatically flattens into an outer container


class Slip


A string of Unicode codepoints


class Uni


Mutable uint8 buffer for utf8 binary data


class utf8


Table for "our"-scoped symbols


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

class Stash


Built-in class for strings. Objects of type C<Str> are
L<immutable|/language/faq#If_Str_is_immutable,_how_does_s///_work?_If_Int_is_immutable,_how_does_$i%2B%2B_work?>.


head

multi method chop(Str:D:)
multi method chop(Str:D: Int() $chopping)


Returns the string with C<$chopping> characters removed from the end.


say "Whateverable".chop(3.6);  # OUTPUT: «Whatevera␤»
my $string= "Whateverable";
say $string.chop("3");         # OUTPUT: «Whatevera␤»


The C<$chopping> positional is converted to L<C<Int>|/type/Int> before being applied to the
string.


multi        chomp(Str:D  --> Str:D)
multi method chomp(Str:D: --> Str:D)


Returns the string with a logical newline (any codepoint that has the
C<NEWLINE> property) removed from the end.


say chomp("abc\n");       # OUTPUT: «abc␤»
say "def\r\n".chomp;      # OUTPUT: «def␤» NOTE: \r\n is a single grapheme!
say "foo\r".chomp;        # OUTPUT: «foo␤»


multi method contains(Str:D: Cool:D $needle, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)
multi method contains(Str:D: Str:D $needle, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)
multi method contains(Str:D: Regex:D $needle --> Bool:D)
multi method contains(Str:D: Cool:D $needle, Int(Cool:D) $pos, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)
multi method contains(Str:D: Str:D $needle, Int:D $pos, :i(:$ignorecase), :m(:$ignoremark) --> Bool:D)
multi method contains(Str:D: Regex:D $needle, Int:D $pos --> Bool:D)
multi method contains(Str:D: Regex:D $needle, Cool:D $pos --> Bool:D)


Given a C<Str> invocant (known as the I<haystack>) and a first argument
(known as the C<$needle>), it searches for the C<$needle> in the I<haystack>
from the beginning of the string and returns C<True> if C<$needle> is found.
If the optional parameter C<$pos> is provided, then C<contains> will
search the I<haystack> starting from C<$pos> characters into the string.


say "Hello, World".contains('Hello');      # OUTPUT: «True␤»
say "Hello, World".contains('hello');      # OUTPUT: «False␤»
say "Hello, World".contains('Hello', 1);   # OUTPUT: «False␤»
say "Hello, World".contains(',');          # OUTPUT: «True␤»
say "Hello, World".contains(',', 3);       # OUTPUT: «True␤»
say "Hello, World".contains(',', 10);      # OUTPUT: «False␤»


In the first case, C<contains> searches for the C<'Hello'> string on the
invocant right from the start of the invocant string and returns C<True>.
In the third case, the C<'Hello'> string is not found since we have
started looking from the second position (index 1) in C<'Hello, World'>.


Since Rakudo version 2020.02, the C<$needle> can also be
a L<C<Regex>|/type/Regex> in which case the C<contains> method
quickly returns whether the regex matches the string at least
once. No L<C<Match>|/type/Match> objects are created, so this is
relatively fast.


say 'Hello, World'.contains(/\w <?before ','>/);    # OUTPUT: «True␤»
say 'Hello, World'.contains(/\w <?before ','>/, 5); # OUTPUT: «False␤»


Since Rakudo version 2020.02, if the optional named parameter
C<:ignorecase>, or C<:i>, is specified, the search for C<$needle>
ignores the distinction between upper case, lower case and title
case letters.


say "Hello, World".contains("world");              # OUTPUT: «False␤»
say "Hello, World".contains("world", :ignorecase); # OUTPUT: «True␤»


Since Rakudo version 2020.02, if the optional named parameter
C<:ignoremark>, or C<:m>, is specified, the search for C<$needle>
only considers base characters, and ignores additional marks such as
combining accents.


say "abc".contains("ä");               # OUTPUT: «False␤»
say "abc".contains("ä", :ignoremark);  # OUTPUT: «True␤»


Note that because of how a L<C<List>|/type/List> or L<C<Array>|/type/Array> is
L<coerced|/type/List#method_Str> into a C<Str>, the results may
sometimes be surprising.


say <Hello, World>.contains('Hello');    # OUTPUT: «True␤»
say <Hello, World>.contains('Hello', 0); # OUTPUT: «True␤»
say <Hello, World>.contains('Hello', 1); # OUTPUT: «False␤»


See L<traps|/language/traps#Lists_become_strings,_so_beware_.contains()>.


multi        lc(Str:D  --> Str:D)
multi method lc(Str:D: --> Str:D)


Returns a lower-case version of the string.


lc("A"); # OUTPUT: «"a"»
"A".lc;  # OUTPUT: «"a"»


multi        uc(Str:D  --> Str:D)
multi method uc(Str:D: --> Str:D)


Returns an uppercase version of the string.


multi        fc(Str:D  --> Str:D)
multi method fc(Str:D: --> Str:D)


Does a Unicode "fold case" operation suitable for doing caseless
string comparisons.  (In general, the returned string is unlikely to
be useful for any purpose other than comparison.)


multi        tc(Str:D  --> Str:D)
multi method tc(Str:D: --> Str:D)


Does a Unicode "titlecase" operation, that is changes the first character in
the string to title case, or to upper case if the character has no title case
mapping


multi        tclc(Str:D  --> Str:D)
multi method tclc(Str:D: --> Str:D)


Turns the first character to title case, and all other characters to lower
case


Returns a string in which C<&filter> has been applied to all the words
that match C<$where>. By default, this means that the first letter of
every word is capitalized, and all the other letters lowercased.


Native integer


class int


Dual value number and string


class Allomorph


Thing/object


class Any


Abstract representation of a piece of source code


class AST


Integer (native storage at the platform's atomic operation size)


class atomicint


Code object with its own lexical scope


class Block


Captures the current frame state


class CallFrame


Code object


class Code


Encapsulates instructions about how strings should be sorted


class Collation


Information related to the compiler that is being used


class Compiler


Complex number


class Complex


Dual value complex number and string


class ComplexStr


Object that can be treated as both a string and number


class Cool


Scheduler that synchronously executes code on the current thread


class CurrentThreadScheduler


Calendar date


class Date


Calendar date with time


class DateTime


Distribution::Hash


class Distribution::Hash


Distribution::Locally


class Distribution::Locally


Distribution::Path


class Distribution::Path


Every one of the resources installed with a distribution


class Distribution::Resource


Length of time


class Duration


Management of available encodings


class Encoding::Registry


Rational number (arbitrary-precision)


class FatRat


Rakudo-specific class that wraps around code in other languages (generally NQP)


class ForeignCode


Convert values to a string given a format specification


class Format


Produce Callable for given format specification


class Formatter


An object for performing batches of work in parallel with ordered
output


class HyperSeq


Placeholder for multiple unspecified values/arguments


class HyperWhatever


Specific moment in time


class Instant


Integer (arbitrary-precision)


class Int


Dual value integer and string


class IntStr


Logical superposition of values


class Junction


Tagged location in the source code


class Label


A non-blocking, non-re-entrant, mutual exclusion lock


class Lock::Async


Compile-time routine


class Macro


Member function


class Method


The root of the Raku type hierarchy.


class Mu


Absence of a value or a benign failure


class Nil


Floating-point number


class Num


Number or object that can act as a number


role Numeric


Dual value floating-point number and string


class NumStr


Unique identification for an object


class ObjAt


Element of a Signature


class Parameter


Perl related information


class Perl


Item container with custom storage and retrieval


class Proxy


Performs batches of work in parallel without respecting original
order.


class RaceSeq


Raku related information


class Raku


Namespace for holding RakuAST related classes


package RakuAST


Contains the information of a RakuDoc block


class RakuAST::Doc::Block


Contains the declarator docs of a RakuAST object


class RakuAST::Doc::Declarator


Contains the information about RakuDoc markup


class RakuAST::Doc::Markup


Contains the information about a RakuDoc paragraph


class RakuAST::Doc::Paragraph


String of characters


class Str


The Raku Knowledge Base


See Also