Home > Posts > Beginner's Guide to Raku

Beginner's Guide to Raku

  ·   15 min read

Introduction to Raku #

What is Raku? #

Raku (formerly known as Perl 6) is a powerful, dynamic, and highly expressive programming language designed for both beginners and experienced programmers. It’s built on the principles of elegance, readability, and concurrency, offering a modern approach to software development. Raku incorporates many features found in other modern languages while maintaining a unique and powerful paradigm of its own. It prioritizes developer happiness and productivity through features like sophisticated metaprogramming capabilities, built-in concurrency support, and a rich standard library. The language is designed to be easy to learn, yet capable of handling complex tasks with grace.

Why learn Raku? #

Learning Raku offers several compelling advantages:

  • Readability and Maintainability: Raku’s syntax is designed for clarity and ease of understanding. This reduces development time and makes it easier to maintain and collaborate on projects.

  • Modern Features: Raku boasts modern features such as built-in concurrency, powerful regular expressions, advanced type systems (for increased safety and code clarity), and a rich standard library that simplifies many common tasks.

  • Expressiveness and Conciseness: You can often accomplish complex tasks with less code in Raku compared to other languages. This leads to increased productivity and reduced development time.

  • Strong Community: While smaller than some other languages, the Raku community is known for being welcoming and helpful, offering support and resources to learners.

  • Growing Ecosystem: The Raku ecosystem is continuously growing, with new modules and libraries constantly being developed.

Setting up your Raku environment #

The easiest way to get started with Raku is using the official installer for your operating system. You can find the latest installers and instructions at the official Raku website (https://raku.org/). The installation process usually involves downloading an installer and following the on-screen instructions. This will typically add Raku to your system’s PATH, allowing you to run Raku commands from your terminal or command prompt.

Alternatively, some package managers (like apt on Debian/Ubuntu, brew on macOS, or choco on Windows) may offer Raku packages. Consult your package manager’s documentation for specific instructions.

Running your first Raku program #

The simplest Raku program is a “Hello, world!” program. Create a file named hello.raku (or any name ending in .raku) containing the following line:

say "Hello, world!";

To run this program, open your terminal or command prompt, navigate to the directory where you saved the file, and type:

raku hello.raku

Press Enter. You should see “Hello, world!” printed on the console. This simple example demonstrates the basic syntax of Raku—using the say function to output text to the console. Congratulations, you’ve run your first Raku program!

Basic Syntax and Data Types #

Variables and Constants #

Raku uses a sigil system to distinguish variable types. Variables are declared implicitly by assigning a value to them. The sigil indicates the variable’s type and scope.

  • $ (dollar sign): Scalar variable. Holds a single value (e.g., number, string).
  • @ (at sign): Array variable. Holds an ordered list of values.
  • % (percent sign): Hash variable. Holds a collection of key-value pairs.
my $name = "Alice";  # Scalar variable
my @numbers = 1, 2, 3; # Array variable
my %details = name => "Bob", age => 30; # Hash variable

say $name;  # Outputs: Alice
say @numbers; # Outputs: (1 2 3)
say %details; # Outputs: name => "Bob", age => 30

Constants are declared using the constant keyword. Their values cannot be changed after declaration.

constant $PI = 3.14159;
# $PI = 3.14;  # This would result in a compile-time error

The my keyword declares lexical variables, which are scoped to the block of code in which they are defined. Variables declared without my (though generally discouraged) are package variables, having broader scope.

Data Types (Scalars, Lists, Hashes) #

Raku’s fundamental data types include:

  • Scalars: Represent single values. They can be of various types, including:

    • Integers: Whole numbers (e.g., 10, -5, 0).
    • Numbers: Floating-point numbers (e.g., 3.14, -2.5).
    • Strings: Sequences of characters (e.g., “Hello”, ‘Raku’).
    • Booleans: True or False.

  • Lists: Ordered collections of values. They are created using commas , or the [...] syntax.

    my @list = 1, 2, 3, "four"; # List of mixed types
my @anotherList = [5, 6, 7]; # Another way to define a list

  • Hashes: Unordered collections of key-value pairs. Keys are typically strings, but can be other data types as well. They are created using => or the { } syntax.

    my %hash = name => "Charlie", age => 25; # Using =>
my %anotherHash = { city => "New York", country => "USA" }; # Using curly braces

Operators #

Raku supports a wide range of operators, including:

  • Arithmetic Operators: +, -, *, /, % (modulo), ** (exponentiation).
  • Comparison Operators: == (equal to), != (not equal to), > (greater than), < (less than), >= (greater than or equal to), <= (less than or equal to).
  • Logical Operators: && (and), || (or), ! (not).
  • String Operators: .join (concatenates strings), ~~ (smartmatch operator).
  • Assignment Operators: =, +=, -=, *=, /=, etc.

Control Flow (if/else, loops) #

  • if/elsif/else statements: Used for conditional execution.
my $x = 10;
if $x > 5 {
    say "x is greater than 5";
} elsif $x == 5 {
    say "x is equal to 5";
} else {
    say "x is less than 5";
}
  • for loop: Iterates over a list or range.
for 1..5 -> $i { # Iterates from 1 to 5
    say $i;
}

for @numbers -> $num { # Iterates over the array @numbers
    say $num;
}
  • while loop: Repeats a block of code as long as a condition is true.
my $count = 0;
while $count < 3 {
    say $count;
    $count++;
}
  • loop loop: A general-purpose loop that continues indefinitely until explicitly stopped using last, break, or a condition within.
loop {
    say "Looping...";
    last if $count >= 5; # Exit the loop if count is 5 or more.
    $count++;
}

These are the fundamental building blocks for creating more complex Raku programs. Remember to consult the official Raku documentation for more in-depth explanations and advanced features.

Working with Data #

Input and Output #

Raku provides several ways to handle input and output:

Output: The simplest way to output data is using the say function, which automatically adds a newline character at the end:

say "Hello, world!";
say 1 + 2;  # Outputs 3

For more fine-grained control, use print:

print "This is a line. ";
print "This is on the same line.\n"; # \n adds a newline explicitly.

Input: The prompt function is used to get input from the user:

my $name = prompt "What is your name? ";
say "Hello, $name!";

For reading from a file, use the slurp function (for reading entire file content into a string) or the IO::Handle class for more complex file operations:

my $file-content = slurp("my-file.txt");
say $file-content;

my $fh = open("my-file.txt", :r); #open file for reading
while $fh.more {
    my $line = $fh.get;
    say $line;
}
$fh.close;

Remember to handle potential errors when working with files (e.g., file not found).

Working with Strings #

Raku provides extensive support for string manipulation. Strings are enclosed in double quotes (") or single quotes ('). Double-quoted strings allow for interpolation (embedding variables within the string):

my $name = "Alice";
say "Hello, $name!";  # Interpolation; outputs "Hello, Alice!"
say 'Hello, $name!';  # No interpolation; outputs "Hello, $name!"

String methods include:

  • .uc (uppercase), .lc (lowercase), .title (title case)
  • .contains (checks if a substring exists)
  • .substr (extracts a substring)
  • .index (finds the index of a substring)
  • .chop (removes the last character)

Working with Numbers #

Raku handles integers and floating-point numbers seamlessly. Basic arithmetic operations are straightforward:

my $a = 10;
my $b = 3;
say $a + $b;  # Addition
say $a - $b;  # Subtraction
say $a * $b;  # Multiplication
say $a / $b;  # Division (floating-point result)
say $a % $b;  # Modulo (remainder)

Raku also provides numerous math functions via the Math module:

use Math;
say sqrt(25); # Square root
say sin(π/2); # Sine function (requires importing π)

Data Structures (Arrays, Hashes) #

Arrays: Ordered collections of elements. Access elements using their index (starting from 0):

my @array = <apple banana cherry>;
say @array[0]; # Outputs: apple
say @array.elems; #Number of elements in the array
@array.push("date"); # Add an element to the end
say @array;

Hashes: Collections of key-value pairs. Access values using their keys:

my %hash = fruit => "apple", color => "red";
say %hash<fruit>;  # Outputs: apple
say %hash.keys; #Outputs keys as a list
say %hash.values; #Outputs values as a list
%hash<size> = "medium"; # Add a new key-value pair

Arrays and hashes can contain elements of different data types. Raku provides many built-in methods for manipulating arrays and hashes (e.g., sorting, searching, filtering). Refer to the Raku documentation for a complete list.

Functions and Subroutines #

Defining Functions #

In Raku, functions (and subroutines; the terms are often used interchangeably) are defined using the sub keyword followed by the function name, parameters in parentheses, and the code block enclosed in curly braces {}:

sub greet(Str $name) {
    say "Hello, $name!";
}

greet("Alice");  # Calls the greet function

This defines a function named greet that takes a single string parameter $name and prints a greeting. The Str indicates that the parameter $name should be a string.

Function Parameters #

Functions can accept multiple parameters, and you can specify parameter types for better type safety and code clarity. Parameters can have default values:

sub add(Int $a, Int $b = 0) { # $b has a default value of 0
    return $a + $b;
}

say add(5, 3);   # Outputs 8
say add(10);    # Outputs 10 (uses default value for $b)

sub describe(Str $name, Int $age, Str $city is optional) {
    say "$name is $age years old";
    if $city {
        say "and lives in $city";
    }
}

describe("Bob", 30, "New York");
describe("Alice", 25); # city is optional.

The is optional trait makes the $city parameter optional. If not provided, it is treated as Nil.

Return Values #

Functions return values using the return keyword or implicitly by the last statement evaluated.

sub square(Numeric $x) {
    return $x * $x; # Explicit return
}

sub cube(Numeric $x) {
    $x * $x * $x # Implicit return
}

say square(5);   # Outputs 25
say cube(2);    #Outputs 8

Anonymous Functions #

Anonymous functions (also called closures or lambdas) are functions without a name. They are defined using the -> operator:

my $add = -> Int $a, Int $b { $a + $b };  # Anonymous function assigned to $add
say $add(7, 2);  # Outputs 9

my @numbers = 1..5;
my @squares = @numbers.map( -> Int $n { $n * $n }); # Using an anonymous function with map
say @squares; # Outputs (1 4 9 16 25)

Anonymous functions are particularly useful when you need a short, simple function that is only used once, like within the map method above. They improve code readability and reduce the need for defining many small named functions.

Object-Oriented Programming in Raku #

Classes and Objects #

Raku supports object-oriented programming (OOP) through classes and objects. A class is a blueprint for creating objects. Objects are instances of a class. Classes are defined using the class keyword:

class Dog {
    has Str $.name;
    has Int $.age;

    method greet() {
        say "Woof! My name is {$.name}.";
    }
}

my $dog1 = Dog.new(name => "Buddy", age => 3);
$dog1.greet();  # Outputs: Woof! My name is Buddy.
say $dog1.name; #Outputs: Buddy

This defines a Dog class with attributes (instance variables) name and age. The .new method is used to create new objects (instances) of the class, and it initializes the object’s attributes using named parameters. The has keyword declares instance variables, automatically creating accessors (getters and setters).

Methods #

Methods are functions defined within a class. They operate on the object’s data:

class Cat {
    has Str $.name;
    has Int $.age;

    method meow() {
        say "Meow!";
    }

    method describe() {
        say "My name is {$.name}, and I am {$.age} years old.";
    }
}

my $cat1 = Cat.new(name => "Whiskers", age => 5);
$cat1.meow();       # Outputs: Meow!
$cat1.describe();   # Outputs: My name is Whiskers, and I am 5 years old.

Methods access the object’s attributes using the $ sigil followed by the attribute name.

Inheritance #

Inheritance allows you to create new classes based on existing classes. The new class inherits the attributes and methods of the parent class:

class Animal {
    has Str $.name;
    has Int $.age;

    method speak() {
        say "Generic animal sound";
    }
}

class Dog is Animal {  # Dog inherits from Animal
    method speak() {
        say "Woof!";
    }
}

my $animal = Animal.new(name => "Generic", age => 1);
my $dog = Dog.new(name => "Fido", age => 2);

$animal.speak(); # Outputs: Generic animal sound
$dog.speak();    # Outputs: Woof!

The is keyword indicates inheritance. The Dog class inherits name and age and overrides the speak method.

Polymorphism #

Polymorphism allows objects of different classes to respond to the same method call in their own specific way. This is demonstrated in the inheritance example above: both Animal and Dog have a speak method, but they produce different outputs. This is a key benefit of OOP in Raku, enabling flexibility and code reusability. Another example could be using a common interface:

role SoundMaker {
    method make-sound() {
        say "A generic sound";
    }
}

class Dog does SoundMaker {
    method make-sound() {
        say "Woof!";
    }
}

class Cat does SoundMaker {
    method make-sound() {
        say "Meow!";
    }
}

my $dog = Dog.new;
my $cat = Cat.new;
$dog.make-sound(); #Woof!
$cat.make-sound(); #Meow!

Here, Dog and Cat both implement the make-sound method from the SoundMaker role, resulting in polymorphic behaviour. Roles provide a way to add behaviour to classes without using inheritance directly, improving code flexibility and maintainability.

Advanced Topics #

Exception Handling #

Raku uses try, catch, and finally blocks for exception handling. Exceptions are objects that represent errors or exceptional situations during program execution.

try {
    my $result = 10 / 0; # This will cause a division by zero error
    say $result;
} catch {
    when X::DivisionByZero {
        say "Division by zero error!";
    }
    when Exception {  # Catch any other exception
        say "An error occurred: {$_.message}";
    }
} finally {
    say "This always executes.";
}

The try block contains the code that might throw an exception. The catch block handles specific exceptions using when. The finally block executes regardless of whether an exception occurred.

Modules and Packages #

Modules and packages organize Raku code into reusable units. Modules contain code, while packages group related modules. Modules are imported using the use keyword:

use Math; #Import the Math module

say sqrt(25); # Use a function from the Math module

Creating your own module involves placing code in a file named <modulename>.raku (e.g., MyModule.raku) and using the module keyword:

# MyModule.raku
module MyModule;

sub greet(Str $name) {
    say "Hello from MyModule, $name!";
}

Then, you would import it into another file:

use MyModule;

greet("World"); #Calls the greet subroutine from MyModule

Packages provide a way to group related modules to avoid naming conflicts.

Concurrency and Parallelism #

Raku offers built-in support for concurrency and parallelism. Concurrency involves managing multiple tasks seemingly at the same time, while parallelism involves running multiple tasks truly simultaneously on multiple cores.

Concurrency: Raku’s start keyword allows you to create and manage asynchronous tasks:

my $promise = start {
    sleep 2;
    return "Task completed!";
};

say "Doing other things...";
say $promise.await;  # Wait for the task to finish and get its result

Parallelism: Raku’s react construct enables running multiple tasks in parallel:

react {
    whenever supply 1..5 -> $i {
      say "Processing number: $i";
    }
}

Note that react is a more advanced feature and will require understanding of asynchronous programming concepts.

Metaprogramming #

Metaprogramming involves writing code that manipulates or generates other code at compile time or runtime. Raku’s powerful metaprogramming capabilities allow you to create DSLs (domain-specific languages), code generation tools, and other advanced features:

my class MyClass {
    method foo() {
        say "Hello from foo";
    }
}

# Generate a method dynamically
MyClass.add_method("bar", -> { say "Hello from bar"; });

my $obj = MyClass.new;
$obj.foo();   # Outputs: Hello from foo
$obj.bar();   # Outputs: Hello from bar

Here, add_method dynamically adds a new method to the class at runtime. Raku provides many advanced features for metaprogramming, but this requires a deeper understanding of the language’s internals.

Next Steps #

Where to learn more #

This beginner’s guide provides a foundational understanding of Raku. To deepen your knowledge and explore advanced topics, consider these resources:

  • The official Raku website: https://raku.org/ This is the central hub for all things Raku, including documentation, tutorials, and community links. The documentation is comprehensive, though it can be challenging for absolute beginners.

  • Raku documentation: The official documentation is extensive and covers all aspects of the language. Start with the “Beginner’s Guide” section if you’re new to Raku.

  • Online tutorials and courses: Numerous online tutorials and courses are available for learning Raku. Search for “Raku tutorial” or “Raku course” on platforms like YouTube, Udemy, and Coursera.

  • Books: Several books on Raku programming have been published, offering a structured learning approach. Check online bookstores for available titles.

Community Resources #

The Raku community is welcoming and supportive. Engage with the community to learn from experienced programmers, ask questions, and share your knowledge:

  • Raku Conference: The annual Raku conference is a great opportunity to meet other Raku users and learn about the latest developments.

  • Raku mailing lists: The Raku community has active mailing lists where you can ask questions, discuss topics, and receive help from experienced developers.

  • Raku forums and discussion groups: Several online forums and discussion groups dedicated to Raku provide a platform for interacting with the community.

  • IRC channels: Many Raku users participate in IRC channels dedicated to Raku programming, which are good places for immediate help.

Contributing to Raku #

If you’re interested in contributing to the Raku project, there are many ways to get involved:

  • Reporting bugs: Find and report bugs you encounter while using Raku. The developers value bug reports to help improve the language.

  • Submitting patches: If you have programming skills, you can contribute by fixing bugs, implementing new features, or improving the existing codebase.

  • Improving documentation: Help enhance the Raku documentation by writing tutorials, improving existing documentation, or translating it into different languages.

  • Creating modules and libraries: Develop and release new modules and libraries that extend the functionality of Raku.

  • Mentoring beginners: Help new Raku programmers by answering their questions, providing guidance, and contributing to the community’s learning resources.

Contributing to an open-source project like Raku is a rewarding experience that enables you to hone your skills, collaborate with others, and make a tangible impact on the development of the language. Check the Raku project’s website for guidelines on contributing.

←
Beginner's Guide to Pascal
Beginner's Guide to Haxe
→
back to top