TITLE

SUBTITLE

class Uni does Positional[uint32] does Stringy { }


Unlike L<C<Str>|/type/Str>, which is made of Grapheme clusters, Uni is string
strictly made of Unicode codepoints. That is, base characters and combining
characters are separate elements of a C<Uni> instance.


C<Uni> presents itself with a list-like interface of integer Codepoints.


Typical usage of C<Uni> is through one of its subclasses, L<C<NFC>|/type/NFC>, L<C<NFD>|/type/NFD>,
L<C<NFKD>|/type/NFKD> and L<C<NFKC>|/type/NFKC>, which represent strings in one of the L<Unicode Normalization Forms|https://www.unicode.org/reports/tr15/> of the same name.


head

Creates a new C<Uni> instance from the given codepoint numbers.


Returns a L<C<Seq>|/type/Seq> of integer codepoints.


Returns an L<C<NFC>|/type/NFC> (Normal Form Composed)-converted version of the invocant.


Returns an L<C<NFD>|/type/NFD> (Normal Form Decomposed)-converted version of the invocant.


Returns an L<C<NFKC>|/type/NFKC> (Normal Form Compatibility Composed)-converted version of the invocant.


Returns an L<C<NFKD>|/type/NFKD> (Normal Form Compatibility Decomposed)-converted version of the invocant.


Returns the number of codepoints in the invocant.


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


Table for "our"-scoped symbols


class Stash


Mutable uint8 buffer for utf8 binary data


class utf8


A string of Unicode codepoints


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 Uni


Built-in class for providing Unicode related information.  Although it
can be instantiated, these methods currently mostly make sense when called
as class methods.  In which case they represent the information of the
supported version of Unicode in the current runtime.


Available as of release 2023.02 of the Rakudo compiler.  Available as an
L<installable module|https://raku.land/zef:lizmat/Unicode> for earlier
versions of the Rakudo compiler.


Returns a L«C<Version>|/type/Version» object representing the Unicode
version.


say Unicode.version; # OUTPUT: «v15.0␤»


Returns a L«C<Bool>|/type/Bool» indicating whether complete
L«C<Normalization Form Grapheme>|/language/glossary#NFG» support is
available.


# on MoarVM
say Unicode.NFG; # OUTPUT: «True␤»


# on JVM
say Unicode.NFG; # OUTPUT: «False␤»


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


class CompUnit::Repository::Installation


Distribution related information


class Distro


Formal grammar made up of named regexes


class Grammar


Iterate over contents of files specified on command line


class IO::ArgFiles


Use multiple IO handles as if they were one


class IO::CatHandle


Opened file or stream


class IO::Handle


Asynchronous notification for file and directory changes





class IO::Notification


Changes in a file, produced by watch-file


class IO::Notification::Change


File or directory path


class IO::Path


IO::Path pre-loaded with IO::Spec::Cygwin


class IO::Path::Cygwin


IO::Path parts encapsulation


class IO::Path::Parts


IO::Path pre-loaded with IO::Spec::QNX


class IO::Path::QNX


IO::Path pre-loaded with IO::Spec::Unix


class IO::Path::Unix


IO::Path pre-loaded with IO::Spec::Win32


class IO::Path::Win32


Buffered inter-process string or binary stream


class IO::Pipe


Asynchronous socket in TCP or UDP


class IO::Socket::Async


A tap for listening TCP sockets


class IO::Socket::Async::ListenSocket


TCP Socket


class IO::Socket::INET


Platform specific operations on file and directory paths


class IO::Spec


Platform specific operations on file and directory paths for Cygwin


class IO::Spec::Cygwin


Platform specific operations on file and directory paths QNX


class IO::Spec::QNX


Platform specific operations on file and directory paths for POSIX


class IO::Spec::Unix


Platform specific operations on file and directory paths for Windows


class IO::Spec::Win32


Path to special I/O device


class IO::Special


Kernel related information


class Kernel


A low-level, re-entrant, mutual exclusion lock


class Lock


Condition variables used in locks


class Lock::ConditionVariable


Result of a successful regex match


class Match


Block in a Pod document


class Pod::Block


Verbatim code block in a Pod document


class Pod::Block::Code


Comment in a Pod document


class Pod::Block::Comment


Declarator block in a Pod document


class Pod::Block::Declarator


Named block in a Pod document


class Pod::Block::Named


Paragraph in a Pod document


class Pod::Block::Para


Table in a Pod document


class Pod::Block::Table


Pod definition list


class Pod::Defn


Pod formatting code


class Pod::FormattingCode


Heading in a Pod document


class Pod::Heading


Item in a Pod enumeration list


class Pod::Item


Running process (filehandle-based interface)


class Proc


Running process (asynchronous interface)


class Proc::Async


Status/result of an asynchronous computation


class Promise


String pattern


class Regex


Control access to shared resources by multiple threads


class Semaphore


Live Supply factory


class Supplier


Cached live Supply factory


class Supplier::Preserving


Asynchronous data stream with multiple subscribers


class Supply


Subscription to a Supply


class Tap


Concurrent execution of code (low-level)


class Thread


Scheduler that distributes work among a pool of threads


class ThreadPoolScheduler


Raku Virtual Machine related information


class VM


Unicode related information


class Unicode


The C<UInt> is defined as a subset of L<C<Int>|/type/Int>:


code

Consequently, it cannot be instantiated or subclassed; however, that shouldn't affect most normal uses.


say UInt ~~ Int; # OUTPUT: «True␤»
my UInt $u = 0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff; # 64-bit unsigned value
say $u.base(16); # OUTPUT: «FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF␤» (32 digits)
++$u;
say $u.base(16); # OUTPUT: «100000000000000000000000000000000␤» (33 digits!)
my Int $i = $u;
say $i.base(16); # same as above
say $u.^name;    # OUTPUT: «Int␤» - UInt is a subset, so the type is still Int.
say $i.^name;    # OUTPUT: «Int␤»
# Difference in assignment
my UInt $a = 5;  # nothing wrong
my UInt $b = -5; # Exception about failed type check
my UInt $c = 0;
--$c;            # Exception again
CATCH { default { put .^name, ': ', .Str } };
# OUTPUT: «X::TypeCheck::Assignment: Type check failed in assignment to $b; expected UInt but got Int (-5)␤»


# Non-assignment operations are fine
my UInt $d = 0;
say $d - 3;      # OUTPUT: «-3␤»


class Uni

Methods

method new

method list

method NFC

method NFD

method NFKC

method NFKD

method codes

method elems

See Also