TITLE

SUBTITLE

C<PseudoStash> is the stash type (hanging off C<.WHO>) that backs
various pseudo-packages. So, when you do C<MY::> or C<CALLER::>, that
gives back a C<PseudoStash>. In most cases, C<Package::> gives
back a L<C<Stash>|/type/Stash>. Neither of these are objects the user is expected to
create by themselves, but in case you have one, you can just use it like a
hash.


code

This shows how you can use a C<PseudoStash> to look up variables, by name,
at runtime.


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


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


Table for "our"-scoped symbols


class Stash


A string of Unicode codepoints


class Uni


Mutable uint8 buffer for utf8 binary data


class utf8


Stash type for pseudo-packages


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 PseudoStash


Object hashes with a limitation on the type of values


The C<QuantHash> role provides the basic functionality shared by the
L<C<Setty>|/type/Setty>, L<C<Baggy>|/type/Baggy> and L<C<Mixy>|/type/Mixy> roles.  These
provide object hashes whose values are limited in some way.


C<QuantHashes> are what L<set operators|/language/setbagmix> use internally.


head

Coerces the C<QuantHash> object to a L<C<Hash>|/type/Hash> (by stringifying the objects
for the keys) with the values of the hash limited to the same limitation as
C<QuantHash>, and returns that.


Coerces the C<QuantHash> object to a L<C<Hash>|/type/Hash> (by stringifying the objects
for the keys) without any limitations on the values, and returns that.


Available as of the 2021.02 release of the Rakudo compiler.


Coerces the C<QuantHash> object to a L<C<Map>|/type/Map> (by stringifying the objects
for the keys) without any limitations on the values, and returns that.


Returns the type of value a key of this subclass of C<QuantHash> may have. This
is typically L<C<Mu>|/type/Mu>, which is also the default for punned QuantHashes.


Returns the object as a L<C<Capture>|/type/Capture> by previously coercing it to a L<C<Hash>|/type/Hash>.


Returns a list of L<C<Pair>|/type/Pair> objects of all keys and values in the
QuantHash.


Coerce the C<QuantHash> object to the equivalent object that uses the L<C<Setty>|/type/Setty>
role. Note that for L<C<Mixy>|/type/Mixy> type coercion items with negative values will be skipped.


my %b is Bag = one => 1, two => 2;
say %b.Setty; # OUTPUT: «Set(one two)␤»
my %m is Mix = one => 1, minus => -1;
say %m.Setty; # OUTPUT: «Set(one)␤»


Coerce the C<QuantHash> object to the equivalent object that uses the L<C<Baggy>|/type/Baggy>
role. Note that for L<C<Mixy>|/type/Mixy> type coercion items with negative values will be skipped.


my %s is Set = <one two>;
say %s.Baggy; # OUTPUT: «Bag(one two)␤»
my %m is Mix = one => 1, minus => -1;
say %m.Baggy; # OUTPUT: «Bag(one)␤»


Coerce the C<QuantHash> object to the equivalent object that uses the L<C<Mixy>|/type/Mixy>
role.


my %s is Set = <one two>;
say %s.Mixy; # OUTPUT: «Mix(one two)␤»
my %b is Bag = one => 1, two => 2;
say %b.Mixy; # OUTPUT: «Mix(one two(2))␤»


Object that supports looking up values by key


role Associative


Collection of distinct weighted objects


role Baggy


Immutable buffer for binary data ('Binary Large OBject')


role Blob


Mutable buffer for binary data


role Buf


Interface for container objects that can be iterated over


role Iterable


Generic API for producing a sequence of values


role Iterator


Collection of distinct objects with Real weights


role Mixy


Object that supports looking up values by index


role Positional


Failover for binding to a Positional


role PositionalBindFailover


Common methods of sequences


role Sequence


Collection of distinct objects


role Setty


role QuantHash


Item container with custom storage and retrieval


A Proxy is an object that allows you to set a hook that executes whenever a
value is retrieved from a container (C<FETCH>) or when it is set (C<STORE>).
Please note that C<Proxy> can introduce mutability at places where it would
break behavior, e.g. in L<C<Hash>|/type/Hash> keys.


To create a container that returns twice what was stored in it, you do something
like this:


=begin code :method
sub double() is rw {
    my $storage = 0;
    Proxy.new(
        FETCH => method ()     { $storage * 2    },
        STORE => method ($new) { $storage = $new },
    )
}
my $doubled := double();
$doubled = 4;
say $doubled;       # OUTPUT: «8␤»
=end code


method new(:&FETCH!, :&STORE! --> Proxy:D)


Creates a new C<Proxy> object. C<&FETCH> is called with one argument (the
proxy object) when the value is accessed, and must return the value that the
fetch produces. C<&STORE> is called with two arguments (the proxy object, and
the new value) when a new value is stored in the container.


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


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


class Proxy


The Raku Knowledge Base


See Also