head

root

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

README

TITLE

How Raku deals with data structures and what we can expect from them


SUBTITLE

Some classes do not have any I<internal> structure and to access parts
of them, specific methods have to be used. Numbers, strings, and some
other monolithic classes are included in that class. They use the C<$>
sigil, although complex data structures can also use it.


my $just-a-number = 7;
my $just-a-string = "8";


There is a L<Scalar|/type/Scalar> class, which is used internally to assign a default
value to variables declared with the C<$> sigil.


my $just-a-number = 333;
say $just-a-number.VAR.^name; # OUTPUT: «Scalar␤»


Any complex data structure can be I<scalarized> by using the L<item
contextualizer C<$>|/type/Any#index-entry-%24_(item_contextualizer)>:


(1, 2, 3, $(4, 5))[3].VAR.^name.say; # OUTPUT: «Scalar␤»


However, this means that it will be treated as such in the context they are. You
can still access its internal structure.


(1, 2, 3, $(4, 5))[3][0].say; # OUTPUT: «4␤»


An interesting side effect, or maybe intended feature, is that scalarization
conserves identity of complex structures.


for ^2 {
     my @list = (1, 1);
     say @list.WHICH;
} # OUTPUT: «Array|93947995146096␤Array|93947995700032␤»


Every time C<(1, 1)> is assigned, the variable created is going to be different
in the sense that C<===> will say it is; as it is shown, different values of the
internal pointer representation are printed. However


for ^2 {
  my $list = (1, 1);
  say $list.WHICH
} # OUTPUT: «List|94674814008432␤List|94674814008432␤»


In this case, C<$list> is using the Scalar sigil and thus will be a C<Scalar>. Any scalar with the same value will be exactly the same, as shown when printing the pointers.


Complex data structures fall in two different broad categories:
L<Positional|/type/Positional>, or list-like and
L<Associative|/type/Associative>, or key-value pair like, according to how you
access its first-level elements. In general, complex data structures, including
objects, will be a combination of both, with object properties assimilated to
key-value pairs. While all objects subclass L<Mu|/type/Mu>, in general complex objects
are instances of subclasses of L<Any|/type/Any>. While it is theoretically possible to mix
in C<Positional> or C<Associative> without doing so, most methods applicable to
complex data structures are implemented in C<Any>.


Navigating these complex data structures is a challenge, but Raku provides a
couple of functions that can be used on them: L<C<deepmap>|/routine/deepmap> and
L<C<duckmap>|/routine/duckmap>. While the former will go to every single
element, in order, and do whatever the block passed requires,


say [[1, 2, [3, 4]],[[5, 6, [7, 8]]]].deepmap( *.elems );
# OUTPUT: «[[1 1 [1 1]] [1 1 [1 1]]]␤»


which returns C<1> because it goes to the deeper level and applies C<elems> to
them, C<deepmap> can perform more complicated operations:


say [[1, 2, [3, 4]], [[5, 6, [7, 8]]]].duckmap:
   -> $array where .elems == 2 { $array.elems };
# OUTPUT: «[[1 2 2] [5 6 2]]␤»


In this case, it dives into the structure, but returns the element itself if it
does not meet the condition in the block (C<1, 2>), returning the number of
elements of the array if it does (the two C<2>s at the end of each subarray).


Since C<deepmap> and C<duckmap> are C<Any> methods, they also apply to Associative
arrays:


say %( first => [1, 2], second => [3,4] ).deepmap( *.elems );
# OUTPUT: «{first => [1 1], second => [1 1]}␤»


Only in this case, they will be applied to every list or array that is a value,
leaving the keys alone.


C<Positional> and C<Associative> can be turned into each other.


say %( first => [1, 2], second => [3,4] ).list[0];
# OUTPUT: «second => [3 4]␤»


However, in this case, and for Rakudo >= 2018.05, it will return a different
value every time it runs. A hash will be turned into a list of the key-value
pairs, but it is guaranteed to be disordered. You can also do the operation in
the opposite direction, as long as the list has an even number of elements (odd
number will result in an error):


say <a b c d>.Hash # OUTPUT: «{a => b, c => d}␤»


say <a b c d>.Hash.kv # OUTPUT: «(c d a b)␤»


will obtain a different value every time you run it;
L<C<kv>|/type/Pair#method_kv> turns every C<Pair> into a list.


Complex data structures are also generally L<Iterable|/type/Iterable>. Generating an
L<iterator|/routine/iterator> out of them will allow the program to visit the first level of the
structure, one by one:


.say for 'א'..'ס'; # OUTPUT: «א␤ב␤ג␤ד␤ה␤ו␤ז␤ח␤ט␤י␤ך␤כ␤ל␤ם␤מ␤ן␤נ␤ס␤»


C<'א'..'ס'> is a L<Range|/type/Range>, a complex data structure, and with C<for> in front it
will iterate until the list is exhausted. You can use C<for> on your complex
data structures by overriding the L<iterator|/routine/iterator> method (from role C<Iterable>):


class SortedArray is Array {
  method iterator() {
    self.sort.iterator
  }
};
my @thing := SortedArray.new([3,2,1,4]);
.say for @thing; # OUTPUT: «1␤2␤3␤4␤»


C<for> calls directly the C<iterator> method on C<@thing> making it return the
elements of the array in order. Much more on L<iterating on the page devoted to it|/language/iterating>.


Raku is a functional language and, as such, functions are first-class I<data>
structures. Functions follow the L<Callable|/type/Callable> role, which is the 4th element in
the quartet of fundamental roles. L<Callable|/type/Callable> goes with the C<&> sigil, although
in most cases it is elided for the sake of simplicity; this sigil elimination is
always allowed in the case of C<Callables>.


my &a-func= { (^($^þ)).Seq };
say a-func(3), a-func(7); # OUTPUT: «(0 1 2)(0 1 2 3 4 5 6)␤»


L<Block|/type/Block>s are the simplest callable structures, since C<Callable>s cannot be
instantiated. In this case we implement a block that logs events and can
retrieve them:


my $logger = -> $event, $key = Nil  {
  state %store;
  if ( $event ) {
    %store{ DateTime.new( now ) } = $event;
  } else {
    %store.keys.grep( /$key/ )
  }
}
$logger( "Stuff" );
$logger( "More stuff" );
say $logger( Nil, "2018-05-28" ); # OUTPUT: «(Stuff More stuff)␤»


A C<Block> has a L<Signature|/type/Signature>, in this case two arguments, the first of
which is the event that is going to be logged, and the second is the key
to retrieve the events. They will be used in an independent way, but its
intention is to showcase the use of a L<state variable|/syntax/state>
that is kept from every invocation to the next. This state variable is
encapsulated within the block, and cannot be accessed from outside
except by using the simple API the block provides: calling the block
with a second argument. The two first invocations log two events, the
third invocation at the bottom of the example use this second type of
call to retrieve the stored values. C<Block>s can be cloned:


code

=begin code :preamble<my $logger = sub ( $a, $b ){ return $a, $b }>
my $clogger = $logger.clone;
$clogger( "Clone stuff" );
$clogger( "More clone stuff" );
say $clogger( Nil, "2018-05-28" );
# OUTPUT: «(Clone stuff More clone stuff)␤»
=end code


And cloning will reset the state variable; instead of cloning, we can create
I<façades> that change the API. For instance, eliminate the need to use C<Nil>
as first argument to retrieve the log for a certain date:


=begin code :preamble<my $logger = sub ( $a, $b ){ return $a, $b }>
my $gets-logs = $logger.assuming( Nil, * );
$logger( %(changing => "Logs") );
say $gets-logs( "2018-05-28" );
# OUTPUT: «({changing => Logs} Stuff More stuff)␤»
=end code


L<C<assuming>|/type/Block#(Code)_method_assuming> wraps around a block
call, giving a value (in this case, C<Nil>) to the arguments we need,
and passing on the arguments to the other arguments we represent using
C<*>. In fact, this corresponds to the natural language statement "We
are calling C<$logger> I<assuming> the first argument is C<Nil>". We can
slightly change the appearance of these two Blocks to clarify they are
actually acting on the same block:


=begin code :preamble<my $logger = sub ( $a, $b ){ return $a, $b }>
my $Logger = $logger.clone;
my $Logger::logs = $Logger.assuming( *, Nil );
my $Logger::get = $Logger.assuming( Nil, * );
$Logger::logs( <an array> );
$Logger::logs( %(key => 42) );
say $Logger::get( "2018-05-28" );
=end code


# vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6


Data structures


Learning Raku from Ruby, in a nutshell: what do I already know?


This page attempts to index the high-level differences in syntax and semantics
between Ruby and Raku. Whatever works in Ruby and must be written differently
in Raku should be listed here (whereas many Raku features and idioms won't
be).


Hence this should not be mistaken for a beginner tutorial or overview of Raku; it is intended as a technical reference for Raku learners with a strong
Ruby background.


Ruby detects the end of most statements with a newline (and a few exceptions),
as long as the expression is complete. It is common break up a long expression
by leaving an operator dangling at the end of a line to ensure that the parsing
will continue:


In Raku you must explicitly terminate statements with a C<;>, which allows
for better feedback and more flexibility in breaking up long lines. Two
exceptions not needing an explicit C<;> are the last statement in a block, and
after the closing curly brace of the block itself (if there is nothing else on
that line):


my $x;
...;
if 5 < $x < 10 {
  say "Yep!";
  $x = 17         # No ; required before closing }
}                 # No ; required after closing } because of the newline
say "Done!";      # The ; is not required here if nothing follows


Ruby allows a surprising amount of flexibility in the use of whitespace,
even with strict mode and warnings turned on:


Raku also endorses programmer freedom and creativity, but balanced syntactic
flexibility against its design goal of having a consistent, deterministic,
extensible grammar that supports single-pass parsing and helpful error
messages, integrates features like custom operators cleanly, and doesn't lead
programmers to accidentally misstate their intent. Also, the practice of "code
golf" is slightly de-emphasized; Raku is designed to be more concise in
concepts than in keystrokes.


As a result, there are various places in the syntax where whitespace is
optional in Ruby, but is either mandatory or forbidden in Raku. Many of those
restrictions are unlikely to concern much real-life Perl code (e.g. whitespace
being disallowed between an array variable and its square brackets), but there
are a few that will unfortunately conflict with some Ruby hackers' habitual
coding styles:


item

=begin code :lang<ruby>
if(a < 0); ...; end         # OK in Ruby
=end code


=begin code
my $a; ...;
if ($a < 0) { ... }         # Raku
if $a < 0 { ... }           # Raku, more idiomatic
=end code


=begin code :lang<ruby>
while(x > 5); ...; end      # OK in Ruby
=end code


=begin code
my $x; ...;
while ($x > 5) { ... }      # Raku
while $x > 5 { ... }        # Raku, more idiomatic
=end code


Method call syntax uses a dot just like Ruby:


To call a method whose name is not known until runtime:


If you leave out the quotes, then Raku expects C<$methodname> to contain
a C<Method> object, rather than the simple string name of the method.


Variables, sigils, scope, and common types


In Ruby, variables use sigils primarily to indicate scope. C<$> for global
scope, C<@@> for class scope, C<@> for instance scope, and no sigil for local
variables (including parameters). The C<&> sigil is also used to indicate
method references. Symbols are prefixed with C<:>, but they are not variable
and so not really sigils.


In Raku sigils are primarily used to indicate a role that the contained value
implements, indicating the type (or at least the interface) of the value. The
sigils are invariant, no matter how the variable is being used - you can think
of them as part of the variable's name.


The scope of a variable is instead indicated by the declaration itself (C<my>,
C<has>, C<our>, etc).


For local variables, Ruby uses implicit variable declaration upon assignment
and limited to the current block. In Ruby the content of an C<if> or C<while>
built-in construct is not a block or scope.


Raku uses explicit scope indicators, and never creates variables implicitly.
Every place you see C<{ ... }> is a scope, including the body of a conditional
or loop. The commonly used scope declarations:


The C<$> sigil is always used with "scalar" variables (e.g. C<$name>). These
are single-value containers.


This is the most general-purpose variable type, with no restrictions on its
contents. Note that you can still address/use its contents, like C<$x[1]>,
C<$x{"foo"}>, and C<$f("foo")>.


The C<@> sigil is always used with "array" variables (e.g. C<@months>,
C<@months[2]>, C<@months[2, 4]> for an array slice). Variables using the C<@>
sigil can only contain things that do the C<Positional> role, indicating
positional indexing and slicing capabilities.


The C<%> sigil is always used with "hash" variables (e.g. C<%calories>,
C<%calories<apple>>, C<%calories<pear plum>>). Variables using the C<%> sigil
can only contain things that do the C<Associative> role.


Ruby uses square brackets to access values for both Arrays and Hashes. Raku
uses curly braces for hashes instead. The angle brackets version is available
which always autoquotes its contents (strings without quotes):


Adverbs can be used to control the type of slice.


The C<&> sigil is used very similarly to Ruby's C<&> to refer to the function
object of a named subroutine/operator without invoking it, i.e. to use the name
as a "noun" instead of a "verb". Variables using the C<&> sigil can only
contain things that do the C<Callable> role.


=begin code :lang<ruby>
add = -> n, m { n + m } # Ruby lambda for an addition function
add.(2, 3)              # => 5, Ruby invocation of a lambda
add.call(2, 3)          # => 5, Ruby invocation of a lambda
=end code


=begin code
my &add = -> $n, $m { $n + $m }; # Raku addition function
&add(2, 3);                      # => 5, you can keep the sigil
add(2, 3);                       # => 5, and it works without it
=end code


Ruby to Raku - nutshell


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

test-pod-docs

Collection-Plugin-Development v0.3.0

Authors

License

Dependencies

Test Dependencies

Provides

Documentation