TITLE

Collection of distinct objects with Real weights


SUBTITLE

A role for collections of weighted values. See L<C<Mix>|/type/Mix> and L<C<MixHash>|/type/MixHash>.
C<Mixy> objects differ from L<C<Baggy>|/type/Baggy> objects in that the weights of
C<Mixy> are L<C<Real>|/type/Real>s rather than L<C<Int>|/type/Int>s.


head

Similar to a L<C<Bag>|/type/Bag>.roll, but with L<C<Real>|/type/Real> weights rather than integral
ones.


Throws an exception. The feature is not supported on the type, since there's no
clear value to subtract from non-integral weights, to make it work.


L<Sets, Bags, and Mixes|/language/setbagmix>


root

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


Object that supports looking up values by index


role Positional


Failover for binding to a Positional


role PositionalBindFailover


Object hashes with a limitation on the type of values


role QuantHash


Common methods of sequences


role Sequence


Collection of distinct objects


role Setty


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 Mixy


The root of the Raku type hierarchy. For the origin of the name, see
L<Mu (negative)|https://en.wikipedia.org/wiki/Mu_%28negative%29> on Wikipedia.
One can also say that there are many undefined values in Raku, and C<Mu> is the
I<most undefined> value.


Note that most classes do not derive from C<Mu> directly, but rather from
L<C<Any>|/type/Any>.


Coerces the invocant to a C<list> by applying its L«C<.list>|/routine/list»
method and uses L«C<iterator>|/type/Iterable#method_iterator» on it.


my $it = Mu.iterator;
say $it.pull-one; # OUTPUT: «(Mu)␤»
say $it.pull-one; # OUTPUT: «IterationEnd␤»


Returns C<False> on a type object, and C<True> otherwise.


say Int.defined;                # OUTPUT: «False␤»
say 42.defined;                 # OUTPUT: «True␤»


A few types (like L<C<Failure>|/type/Failure>) override C<defined> to return
C<False> even for instances:


sub fails() { fail 'oh noe' };
say fails().defined;            # OUTPUT: «False␤»


invokes the C<.defined> method on the object and returns its result.


multi method isa(Mu $type     --> Bool:D)
multi method isa(Str:D $type  --> Bool:D)


Returns C<True> if the invocant is an instance of class C<$type>, a subset type
or a derived class (through inheritance) of C<$type>.
L<C<does>|/routine/does#(Mu)_routine_does> is similar, but includes roles.


my $i = 17;
say $i.isa("Int");   # OUTPUT: «True␤»
say $i.isa(Any);     # OUTPUT: «True␤»
role Truish {};
my $but-true = 0 but Truish;
say $but-true.^name;        # OUTPUT: «Int+{Truish}␤»
say $but-true.does(Truish); # OUTPUT: «True␤»
say $but-true.isa(Truish);  # OUTPUT: «False␤»


Returns C<True> if and only if the invocant conforms to type C<$type>.


code

Unlike L<C<isa>|/routine/isa#(Mu)_routine_isa>, which
returns C<True> only for superclasses, C<does> includes both superclasses and
roles.


Using the smartmatch operator L<~~|/routine/~~> is a more idiomatic alternative.


my $d = Date.new('2016-06-03');
say $d ~~ Dateish;                # OUTPUT: «True␤»
say $d ~~ Any;                    # OUTPUT: «True␤»
say $d ~~ DateTime;               # OUTPUT: «False␤»


multi        Bool(Mu --> Bool:D)
multi method Bool(   --> Bool:D)


Returns C<False> on the type object, and C<True> otherwise.


Many built-in types override this to be C<False> for empty collections, the
empty L<string|/type/Str> or numerical zeros


say Mu.Bool;                    # OUTPUT: «False␤»
say Mu.new.Bool;                # OUTPUT: «True␤»
say [1, 2, 3].Bool;             # OUTPUT: «True␤»
say [].Bool;                    # OUTPUT: «False␤»
say %( hash => 'full' ).Bool;   # OUTPUT: «True␤»
say {}.Bool;                    # OUTPUT: «False␤»
say "".Bool;                    # OUTPUT: «False␤»
say 0.Bool;                     # OUTPUT: «False␤»
say 1.Bool;                     # OUTPUT: «True␤»
say "0".Bool;                   # OUTPUT: «True␤»


Returns a L<C<Capture>|/type/Capture> with named arguments corresponding to
invocant's public attributes:


class Foo {
    has $.foo = 42;
    has $.bar = 70;
    method bar { 'something else' }
}.new.Capture.say; # OUTPUT: «\(:bar("something else"), :foo(42))␤»


Returns a string representation of the invocant, intended to be machine
readable. Method L<C<Str>|/type/Str> warns on type objects, and produces the empty string.


say Mu.Str;   # Use of uninitialized value of type Mu in string context.
my @foo = [2,3,1];
say @foo.Str  # OUTPUT: «2 3 1␤»


multi        gist(+args --> Str)
multi method gist(   --> Str)


Returns a string representation of the invocant, optimized for fast recognition
by humans. As such lists will be truncated at 100 elements. Use C<.raku> to get
all elements.


The default C<gist> method in C<Mu> re-dispatches to the L<raku|/routine/raku>
method for defined invocants, and returns the type name in parenthesis for type
object invocants. Many built-in classes override the case of instances to
something more specific that may truncate output.


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


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


Rational number (limited-precision)


class Rat


Dual value rational number and string


class RatStr


Code object with its own lexical scope and return handling


class Routine


Holds all information needed to unwrap a wrapped routine.


class Routine::WrapHandle


A mostly transparent container used for indirections


class Scalar


Parameter list pattern


class Signature


String of characters


class Str


Contains the result of a string transformation.


class StrDistance


Subroutine


class Sub


Member function that is not inherited by subclasses


class Submethod


Collect performance state for analysis


class Telemetry


Instrument for collecting Thread data


class Telemetry::Instrument::Thread


Instrument for collecting ThreadPoolScheduler data


class Telemetry::Instrument::ThreadPool


Instrument for collecting getrusage data


class Telemetry::Instrument::Usage


Performance data over a period


class Telemetry::Period


Telemetry instrument pod


class Telemetry::Sampler


The root of the Raku type hierarchy.


class Mu


The Raku Knowledge Base


role Mixy

Methods

method roll

method pick

method grab

method kxxv

See Also

See Also