Editing Raku (programming language) (section)

==Examples==
===Hello world===
The [[hello world program]] is a common program used to introduce a language. In Raku, hello world is:
<syntaxhighlight lang="raku">
say 'Hello, world';
</syntaxhighlight>
&mdash; though [[there is more than one way to do it]].

===Factorial===
The [[factorial]] function in Raku, defined in a few different ways: 
<syntaxhighlight lang="raku">
# Using recursion (with `if\else` construct)
sub fact( UInt $n --> UInt ) {
    if $n == 0 { 1 }
    else       { $n * fact($n-1) }
}

# Using recursion (with `if` as statement modifier)
sub fact( UInt $n --> UInt ) {
    return 1 if $n == 0;
    return $n * fact($n-1);
}

# Using recursion (with `when` construct)
sub fact( UInt $n --> UInt ) {
    when $n == 0 { 1 }
    default      { $n * fact($n-1) }
}

# Using the ternary operator
sub fact( UInt $n --> UInt ) {
    $n == 0 ?? 1 !! $n * fact($n-1)
}

# Using multiple dispatch
multi fact(0) { 1 }
multi fact( UInt $n --> UInt ) {
    $n * fact($n - 1)
}

# Using the reduction metaoperator
sub fact( UInt $n --> UInt ) {
    [*] 1..$n
}

# Creating a factorial operator and using the reduction metaoperator
sub postfix:<!>( UInt $n --> UInt ) { [*] 1..$n }

# Using `state` declarator to create a memoized factorial
sub fact( UInt $n --> UInt ) {
    state %known = 0 => 1;
    return %known{$n} if %known{$n}:exists;
    %known{$n} = $n * fact($n-1);
    return %known{$n};
}
</syntaxhighlight>

===Quicksort===
[[Quicksort]] is a well-known sorting algorithm. A working implementation{{efn|Unless the implementation does something fancy and mysterious behind the scenes, the maximal possible recursion depth is the length of the list, making this implementation unsuitable for big data. Recursion depth can be limited to <code>log2(list_length)</code> by iterating into the larger of partitions <code>before</code> and <code>after</code>, and only recursing into the smaller partition.}} using the functional programming paradigm can be succinctly written in Raku:
<syntaxhighlight lang="raku">
# Empty list sorts to the empty list
multi quicksort([]) { () }

# Otherwise, extract first item as pivot...
multi quicksort([$pivot, *@rest]) {
    # Partition.
    my @before = @rest.grep(* < $pivot);
    my @after  = @rest.grep(* >= $pivot);

    # Sort the partitions.
    flat (quicksort(@before), $pivot, quicksort(@after))
}
</syntaxhighlight>

{{notelist}}

===Tower of Hanoi===
[[Tower of Hanoi]] is often used to introduce recursive programming in computer science. This implementation uses Raku's multi-dispatch mechanism and parametric constraints:
<syntaxhighlight lang="raku">
multi sub hanoi(0, $, $, $) { }                         # No disk, so do not do anything
multi sub hanoi($n, $a = 'A', $b = 'B', $c = 'C') {     # Start with $n disks and three pegs A, B, C
    hanoi $n - 1, $a, $c, $b;                           # firstly move top $n - 1 disks from A to B
    say "Move disk $n from peg $a to peg $c";           # then move last disk from A to C
    hanoi $n - 1, $b, $a, $c;                           # lastly move $n - 1 disks from B to C
}
</syntaxhighlight>