TITLE

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


SUBTITLE

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.


head

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


item

Here some modules to help you work with NativeCall.


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


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


Core modules that may be useful to module authors


Core modules


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

Module development utilities


A module is usually a source file or set of source files that expose Raku
constructs N<Technically a module is a set of I<compunits> which are usually
files but could come from anywhere as long as there is a I<compunit repository>
that can provide it. See L<S11|https://design.raku.org/S11.html>.>.


Modules are typically packages (L<classes|/language/objects#Classes>,
L<roles|/language/objects#Roles>, L<grammars|/type/Grammar>),
L<subroutines|/language/functions>, and sometimes
L<variables|/language/variables>. In Raku I<module> can also refer to a type of
package declared with the C<module> keyword (see L<Module
Packages|/language/module-packages> and the examples below) but here we mostly
mean "module" as a set of source files in a namespace.


L<C<zef>|https://github.com/ugexe/zef> is the application used for installing
modules in Raku. Modules are listed in
L<the Raku ecosystem|https://raku.land> and can be searched there or
from the command line using C<zef search>:


code

will return a list of modules that includes WWW in their name, for
instance. Then,


will install the module with that particular name, if it is not already
installed N<If it's installed, it will reinstall only if the version of
the module is newer than the one installed>.


Module distributions (in the I<set of related source files> sense) in Raku
have the same structure as any distribution in the Perl family of languages:
there is a main project directory containing a C<README> and a C<LICENSE> file,
a C<lib> directory for the source files, which may be individually referred to
as modules and/or may themselves define modules with the C<module> keyword N<As
L<synopsis S11|https://design.raku.org/S11.html#Units> says: Confusing? Yes it
is.> , a C<t> directory for tests, and possibly a C<bin> directory for
executable programs and scripts.


See L<filename extensions|/language/filename-extensions> for current and historic
extensions for various file types.


X<Loading and basic importing|Language,compunit>


Loading a module makes the packages in the same namespace declared
within available in the file scope of the loader. Importing from a
module makes the symbols exported available in the lexical scope of
the importing statement.


C<need> loads a C<compunit> at compile time.


Any packages in the namespace defined within will also be available.


=begin code :solo
# MyModule.rakumod
unit module MyModule;

class Class {}
=end code


C<MyModule::Class> will be defined when C<MyModule> is loaded, and you can use
it directly employing its fully qualified name (FQN). Classes and other types
defined that way are not automatically exported; you will need to explicitly
export it if you want to use it by its short name:


=begin code :solo
# MyModule.rakumod
unit module MyModule;

class Class is export {}
=end code


=begin code :skip-test<needs dummy module>
use MyModule;

my $class = Class.new();
say $class.raku;
=end code


C<use> loads and then imports from a compunit at compile time. It will look for
files that end in C<.rakumod>. See L<here|/language/modules#Finding_installed_modules>
for where the runtime will look for modules.


=begin code :skip-test<needs dummy module>
need MyModule;
import MyModule;
=end code


See also
L<selective importing|/language/modules#Exporting_and_selective_importing>
to restrict what you import.


C<require> loads a compunit and imports definite symbols at runtime.


say "loading MyModule";
require MyModule;


The compunit name can be in a runtime variable if you put it inside an
indirect lookup.


my $name = 'MyModule';
require ::($name);


The symbols provided by the loaded module will not be imported into the
current scope. You may use
L<dynamic lookup|/language/packages#index-entry-::()> or
L<dynamic subsets|/language/typesystem#subset> to use them by providing
the fully qualified name of a symbol, for instance:


require ::("Test");
my &mmk = ::("Test::EXPORT::DEFAULT::&ok");
mmk('oi‽'); # OUTPUT: «ok 1 - ␤»


The FQN of C<ok> is C<Test::EXPORT::DEFAULT::&ok>. We are aliasing it to
C<mmk> so that we can use that symbol provided by L<C<Test>|/type/Test> in the current
scope.


To import symbols you must define them at compile time. B<NOTE:>
C<require> is lexically scoped:


sub do-something {
   require MyModule <&something>;
   say ::('MyModule'); # MyModule symbol exists here
   something() # &something will be defined here
}
say ::('MyModule'); # This will NOT contain the MyModule symbol
do-something();
# &something will not be defined here


If C<MyModule> doesn't export C<&something> then C<require> will fail.


A C<require> with compile-time symbol will install a placeholder
C<package> that will be updated to the loaded module, class, or package.
Note that the placeholder will be kept, B<even if require failed to load
the module.> This means that checking if a module loaded like this is
wrong:


# *** WRONG: ***
try require Foo;
if ::('Foo') ~~ Failure { say "Failed to load Foo!"; }
# *** WRONG: ***


As the compile-time installed package causes C<::('Foo')> to never be
a L<C<Failure>|/type/Failure>. The correct way is:


# Use return value to test whether loading succeeded:
(try require Foo) === Nil and say "Failed to load Foo!";


# Or use a runtime symbol lookup with require, to avoid compile-time
# package installation:
try require ::('Foo');
if ::('Foo') ~~ Failure {
    say "Failed to load Foo!";
}


In the current (6.d) version of the language, C<require>d symbols are no longer
transitively exposed, which means that you need to import symbols from the
module they were originally declared, not from the module where they have
been imported.


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)>


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.


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


Module development utilities

Module builder and authoring tools

Tests

NativeCall

Sample modules

See Also