TITLE

Core modules that may be useful to module authors


SUBTITLE

The Rakudo implementation has a few modules included you may want to use; please
note that the implementation is not part of the Raku specification and thus
might be subject to change without prior notice. The following is a list of
them, along with links to their source code.


C<CompUnit::*> modules and roles
X<|Modules,CompUnit (Rakudo classes)>


head

These modules are mostly used by distribution build tools, and are not intended
to be used (at least until version 6.c) by the final user.


item

root

A tutorial about creating and using classes in Raku


Classes and objects


How and when Raku modules are compiled, where they are stored, and how to access them in compiled form.


CompUnits and where to find them


Concurrency and asynchronous programming


Concurrency


Creating your own CLI in Raku


Command line interface


An introduction to grammars


Grammar tutorial


File-related operations


Input/Output


Programs running other programs and communicating with them


Inter-process communication


Functionalities available for visiting all items in a complex data structure


Iterating


Different mathematical paradigms and how they are implemented in this language


Doing math with Raku


Creating module packages for code reuse


Module packages


What can help you write/test/improve your module(s)


Module development utilities


How to create, use, and distribute Raku modules


Modules


A short tutorial on how to declare operators and create new ones.


Creating operators


Some tips on regexes and grammars


Regexes: best practices and gotchas


Read-eval-print loop


REPL


Input methods for unicode characters in terminals, the shell, and editors


Entering unicode characters


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

Core modules


Here is a list of modules that you can find in the Raku ecosystem
which aim to make the experience of developing Raku modules
more fun.


Some modules and tools to help you with generating files that are part
of a module distribution.


Here some modules to help you work with NativeCall.


Modules that exist only as minimalist examples, tests for installers,
or skeletons.


I<N.B.> "Module" is an overloaded term in Raku; this document
focuses on use of the C<module> declarator.


Modules, like classes and grammars, are a kind of
L<package|/language/packages>. Module objects are instances of the
C<ModuleHOW> metaclass; this provides certain capabilities useful for
creating namespaces, versioning, delegation and data encapsulation (see
also L<class|/syntax/class> and L<role|/syntax/role>).


To create a module, use the C<module> declarator:


module M {}
say M.HOW;   # OUTPUT: «Perl6::Metamodel::ModuleHOW.new␤»


Here we define a new module named C<M>; introspection with C<HOW>
confirms that the metaclass underlying C<M> is
C<Perl6::Metamodel::ModuleHOW>.


Modules are primarily useful for encapsulating code and data that
do not belong inside a class or role definition. Module contents
(classes, subroutines, variables, etc.) can be exported from a
module with the C<is export> trait; these are available in the
caller's namespace once the module has been imported with C<import>
or C<use>. A module can also selectively expose symbols within its
namespace for qualified reference via C<our>.


To illustrate module scoping and export rules, let's begin by
defining a simple module C<M>:


module M {
  sub greeting ($name = 'Camelia') { "Greetings, $name!" }
  our sub loud-greeting (--> Str)  { greeting().uc       }
  sub friendly-greeting is export  { greeting('friend')  }
}


Recall that subroutines are lexically scoped unless otherwise specified
(declarator L<C<sub>|/syntax/sub> is equivalent to C<my sub>), so
C<greeting> in the above example is lexically scoped to the module and
inaccessible outside of it. We've also defined C<loud-greeting> with the
C<our> declarator, which means that in addition to being lexically
scoped it is aliased in the module's symbol table. Finally,
C<friendly-greeting> is marked for export; it will be registered in the
I<caller's> symbol table when the module is imported:


code

=begin code :skip-test<needs dummy module>
import M;               # import the module
say M::loud-greeting;   # OUTPUT: «GREETINGS, CAMELIA!␤»
say friendly-greeting;  # OUTPUT: «Greetings, friend!␤»
=end code


While C<.raku> and C<.rakumod> files are sometimes
referred to as "modules", they are really just normal files that
are loaded and compiled when you write C<need>, C<use> or C<require>.


For a C<.rakumod> file to provide a module in the sense that we've been
using, it needs to declare one with C<module> as documented above.
For example, by placing module C<M> inside C<Foo.rakumod>, we can load
and use the module as follows:


=begin code :skip-test<needs dummy module>
use Foo;                # find Foo.rakumod, run need followed by import
say M::loud-greeting;   # OUTPUT: «GREETINGS, CAMELIA!␤»
say friendly-greeting;  # OUTPUT: «Greetings, friend!␤»
=end code


Note the decoupling between file and module names—a C<.rakumod> file
can declare zero or more modules with arbitrary identifiers.


Often we want a C<.rakumod> file to provide a I<single> module and
nothing more. Here a common convention is for the file basename to
match the module name. Returning to C<Foo.rakumod>, it is apparent that
it only provides a single module, C<M>; in this case, we might want
to rename C<M> to C<Foo>. The amended file would then read:


=begin code
module Foo {
  sub greeting ($name = 'Camelia') { "Greetings, $name!" }
  our sub loud-greeting (--> Str)  { greeting().uc       }
  sub friendly-greeting is export  { greeting('friend')  }
}
=end code


which can be used more consistently by the caller (note the
relationship between the C<use Foo> and C<Foo::>):


=begin code :skip-test<needs dummy module>
use Foo;
say Foo::loud-greeting;  # OUTPUT: «GREETINGS, CAMELIA!␤»
say friendly-greeting;   # OUTPUT: «Greetings, friend!␤»
=end code


If C<Foo.rakumod> is placed deeper within the source tree, e.g. at
C<lib/Utils/Foo.rakumod>, we can elect to name the module C<Utils::Foo>
to maintain consistency.


Files that only provide a single module can be written more concisely
with the C<unit> keyword; C<unit module> specifies that the
rest of the compilation unit is part of the declared module. Here's
C<Foo.rakumod> rewritten with C<unit>:


=begin code :solo
unit module Foo;

sub greeting ($name = 'Camelia') { "Greetings, $name!" }
our sub loud-greeting (--> Str)  { greeting().uc       }
sub friendly-greeting is export  { greeting('friend')  }
=end code


Everything following the unit declaration is part of the C<Foo>
module specification.


(Note that C<unit> can also be used with C<class>, C<grammar> and
C<role>.)


To better understand what the C<module> declarator is doing in
C<Foo.rakumod>, let's contrast it with a variant file, C<Bar.rakumod>, that
omits the declaration. The subroutine definitions below are almost
identical (the only difference is in the body of C<greeting>,
modified for clarity):


=begin code
sub greeting ($name = 'Camelia') { "Greetings from Bar, $name!" }
our sub loud-greeting (--> Str)  { greeting().uc                }
sub friendly-greeting is export  { greeting('friend')           }
=end code


As a reminder, here's how we used C<Foo.rakumod> before,


=begin code :skip-test<needs dummy module>
use Bar;
say loud-greeting;       # OUTPUT: «GREETINGS FROM BAR, CAMELIA!␤»
say friendly-greeting;   # OUTPUT: «Greetings from Bar, friend!␤»
=end code


Note the use of C<loud-greeting> rather than C<Bar::loud-greeting>
as C<Bar> is not a known symbol (we didn't create a C<module> of
that name in C<Bar.rakumod>). But why is C<loud-greeting> callable even
though we didn't mark it for export? The answer is simply that
C<Bar.rakumod> doesn't create a new package namespace—C<$?PACKAGE> is
still set to C<GLOBAL>—so when we declare C<loud-greeting> as C<our>,
it is registered in the C<GLOBAL> symbol table.


Thankfully, Raku protects us from accidentally clobbering call
site definitions (e.g. builtins). Consider the following addition
to C<Bar.rakumod>:


our sub say ($ignored) { print "oh dear\n" }


This creates a lexical alias, hiding the C<say> builtin I<inside>
C<Bar.rakumod> but leaving the caller's C<say> unchanged. Consequently,
the following call to C<say> still works as expected:


=begin code :skip-test<needs dummy module>
use Bar;
say 'Carry on, carry on...';  # OUTPUT: «Carry on, carry on...␤»
=end code


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


Core modules

`CompUnit::*` modules and roles

`NativeCall` modules

Other modules

See Also

CompUnit::* modules and roles

NativeCall modules

Other modules

See Also

`CompUnit::*` modules and roles

`NativeCall` modules