TITLE

Codepoint string in Normal Form KD (compatibility decomposed)


SUBTITLE

A Codepoint string in Unicode Normalization Form KD. It is created by Compatibility Decomposition.
For more information on what this means, see L<Unicode TR15|https://www.unicode.org/reports/tr15/>.


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


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


Table for "our"-scoped symbols


class Stash


A string of Unicode codepoints


class Uni


Mutable uint8 buffer for utf8 binary data


class utf8


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 NFKD


The value C<Nil> may be used to fill a spot where a value would normally
go, and in so doing, explicitly indicate that no value is present. It
may also be used as a cheaper and less explosive alternative to a
L<C<Failure>|/type/Failure>.  (In fact, class L<C<Failure>|/type/Failure> is derived from C<Nil>,
so smartmatching C<Nil> will also match L<C<Failure>|/type/Failure>.)


The class C<Nil> is the same exact thing as its only possible value, C<Nil>.


say Nil === Nil.new;        # OUTPUT: «True␤»


Along with L<C<Failure>|/type/Failure>, C<Nil> and its subclasses may always be returned from a
routine even when the routine specifies a particular return type. It may also
be returned regardless of the definedness of the return type, however, C<Nil>
is considered undefined for all other purposes.


sub a( --> Int:D ) { return Nil }
a().say;                    # OUTPUT: «Nil␤»


C<Nil> is what is returned from empty routines or closure, or routines
that use a bare C<return> statement.


sub a { }; a().say;         # OUTPUT: «Nil␤»
sub b { return }; b().say;  # OUTPUT: «Nil␤»
say (if 1 { });             # OUTPUT: «Nil␤»
{ ; }().say;                # OUTPUT: «Nil␤»
say EVAL "";                # OUTPUT: «Nil␤»


In a list, C<Nil> takes the space of one value.  Iterating C<Nil>
behaves like iteration of any non-iterable value, producing a sequence
of one C<Nil>. (When you need the other meaning, the special value
L<Empty|/type/Slip#constant_Empty> is available to take no spaces when inserted into
list, and to return no values when iterated.)


(1, Nil, 3).elems.say;      # OUTPUT: «3␤»
(for Nil { $_ }).raku.say;  # OUTPUT: «(Nil,)␤»


Any method call on C<Nil> of a method that does not exist,
and consequently, any subscripting operation, will succeed and return
C<Nil>.


say Nil.ITotallyJustMadeThisUp;  # OUTPUT: «Nil␤»
say (Nil)[100];                  # OUTPUT: «Nil␤»
say (Nil){100};                  # OUTPUT: «Nil␤»


X<|Language,Nil assignment>
When assigned to a L<container|/language/containers>, the C<Nil> value (but not any subclass of
C<Nil>) will attempt to revert the container to its default value; if no
such default is declared, Raku assumes L<C<Any>|/type/Any>.


Since a hash assignment expects two elements, use C<Empty> not C<Nil>, e.g.


my %h = 'a'..'b' Z=> 1..*;
# stuff happens
%h = Empty; # %h = Nil will generate an error


However, if the container
type is constrained with C<:D>, assigning C<Nil> to it will immediately throw
an exception.  (In contrast, an instantiated L<C<Failure>|/type/Failure> matches C<:D>
because it's a definite value, but will fail to match the actual nominal
type unless it happens to be a parent class of L<C<Failure>|/type/Failure>.) Native types can
not have default values nor hold a type object. Assigning C<Nil> to a native
type container will fail with a runtime error.


my Int $x = 42;
$x = Nil;
$x.say;                     # OUTPUT: «(Int)␤»


sub f( --> Int:D ){ Nil };  # this definedness constraint is ignored
my Int:D $i = f;            # this definedness constraint is not ignored, so throws
CATCH { default { put .^name, ': ', .Str } };
# OUTPUT: «X::TypeCheck::Assignment: Type check failed in assignment to $y; expected Int but got Any (Any)»


sub g( --> Int:D ){ fail "oops" }; # this definedness constraint is ignored
my Any:D $h = g;                   # failure object matches Any:D, so is assigned


code

Because an untyped variable is type L<C<Any>|/type/Any>, assigning a C<Nil> to one
will result in an L<(Any)|/type/Any> type object.


my $x = Nil;
$x.say;          # OUTPUT: «(Any)␤»
my Int $y = $x;  # will throw an exception
CATCH { default { put .^name, ': ', .Str } };
# OUTPUT: «X::TypeCheck::Assignment: Type check failed in assignment to $y; expected Int but got Any (Any)␤»


If you are looking for a variable which transforms objects into type
objects when said variable appears on the right-hand side, you can
type the container as C<Nil>.


my Nil $x;
my Str $s = $x;
$s.say;          # OUTPUT: «(Str)␤»


There is an important exception to this transforms-into-type-object rule:
assigning C<Nil> to a variable which has a default will restore that default.


my Int $x is default(42) = -1;
my $y = 1;
for $x, $y -> $val is rw { $val = Nil unless $val > 0 }
$x.say;          # OUTPUT: «42␤»


Methods such as C<BIND-POS>, C<ASSIGN-KEY>, C<ASSIGN-POS> will die;
C<BIND-KEY> will produce a failure with an L<C<X::Bind>|/type/X::Bind> exception in it, and
C<STORE> will produce an L<C<X::Assignment::RO>|/type/X::Assignment::RO> exception.


head

Warns the user that they tried to append onto a C<Nil> (or derived type object).


Warns the user that they tried to stringify a C<Nil>.


Warns the user that they tried to prepend onto a C<Nil> or derived type object.


Warns the user that they tried to push onto a C<Nil> or derived type object.


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


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


Absence of a value or a benign failure


class Nil


The Raku Knowledge Base


See Also