Then again, go ahead.

First is mypolygon.pl6, getting the hang of the interface.

use v6;
use Swampy;

my $turtle = make-turtle();
say $turtle;
draw-it();

Didn’t actually draw anything, but it did fire up the TurtleWorld display. It even printed out a little bit.

$ perl6 mypolygon.pl6
t1
Python code is in mypolygon.pl6.py

Here are a couple implementation details for you. The turtle has a simple name: t1. And the Python code associated with mypolygon.pl6 will go in mypolygon.pl6.py.

from swampy.TurtleWorld import *

world = TurtleWorld()
t1 = Turtle()

wait_for_user()

Only the Python code relevant to interacting with the swampy library will be written to disk. I expect this means some of the Python code will be tediously long when we get into looping and such. Not concerned about it today. I am amazed it works at all.

Now add the initial sample drawing instructions.

use v6;
use Swampy;

my $bob = make-turtle();
say $bob;

fd($bob, 100);
lt($bob);
fd($bob, 100);

draw-it();

Run it. Woo! A right angle!

Now modify the program to draw a square.

Okay okay. I already know one way to do this because of my Swampy.pm6 adventure.

use v6;
use Swampy;

my $bob = make-turtle();

for 1..4 {
    fd($bob, 100);
    lt($bob);
}

draw-it();

The book suggestion is pretty much the same. Simple loops over ranges where you ignore the counter.

use v6;

for 1..4 {
    say "Hello!";
}

Welcome to looping, kids. It doesn’t look too painful in Perl 6, does it?

Exercises

Exercise 1

Write a function called square that takes a parameter named $t, which is a turtle. It should use the turtle to draw a square.

Write a function call that passes $bob as an argument to square, and then run the program again.

Stand back. I’ve got this.

use v6;
use Swampy;

sub square($t) {
    for 1..4 {
        fd($t, 100);
        lt($t);
    }
}

my $bob = make-turtle();
square($bob);
draw-it();

Exercise 2

Add another parameter, named $length, to square. Modify the body so length of the sides is $length, and then modify the function call to provide a second argument. Run the program again. Test your program with a range of values for $length.

Still not too exciting.

use v6;
use Swampy;

sub square($t, $length) {
    for 1..4 {
        fd($t, $length);
        lt($t);
    }
}

my $bob = make-turtle();

square($bob, 50);
square($bob, 75);
square($bob, 100);

draw-it();

The functions lt and rt make 90 degree turns by default, but you can provide a second argument that specifies the number of degrees. For example, lt($bob, 45) turns $bob 45 degrees to the left.

Make a copy of square and change the name to polygon. Add another parameter named $n and modify the body so it draws an n-sided regular polygon. Hint: the exterior angles of an n-sided regular polygon are 360/n degrees.

BRB, updating Swampy.pm6.

Okay, done.

# ... 

sub polygon($t, $length, $n) {
    my $angle = 360 / $n;
    for 1..$n {
        fd($t, $length);
        lt($t, $angle);
    }
}

my $bob = make-turtle();

polygon($bob, 20, 8);

draw-it();

Exercise 4

Write a function called circle that takes a turtle, $t, and radius, $r, as parameters and that draws an approximate circle by invoking polygon with an appropriate length and number of sides. Test your function with a range of values of $r.

Hint: figure out the circumference of the circle and make sure that $length * $n = $circumference.

Another hint: if $bob is too slow for you, you can speed him up by changing $bob.delay, which is the time between moves, in seconds. $bob.delay = 0.01 ought to get him moving.

Um. That’s right. $bob is actually an object over in Python land. Well, I’m not that far in Perl 6 yet. Let me just add a set-delay($t, $delay) sub.

# ...
my $pi = 3.1415926;

sub circle($t, $r) {
    my $circumference = 2 * $pi * $r;
    my $n = 30;
    my $length = $circumference / $n;
    polygon($t, $length, $n);
}

my $bob = make-turtle();

set-delay($bob, 0.01);
circle($bob, 100);
circle($bob, 10);
circle($bob, 20);
circle($bob, 80);
circle($bob, 60);

draw-it();

Well that was fun. And circle.p6.py has 309 lines.

Exercise 5

Make a more general version of circle called arc that takes an additonal parameter $angle, which determines what fraction of a circle to draw. $angle is in units of degrees, so when $angle=360, arc should draw a complete circle.

Can’t just draw a polygon for this one.

# ...
sub arc($t, $r, $angle) {
    my $arc-length = 2 * $pi * $r * $angle / 360;
    my $step-count = 30;
    my $step-length = $arc-length / $step-count;
    my $step-angle = $angle / $step-count;

    for 1..$step-count {
        fd($t, $step-length);
        lt($t, $step-angle);
    }
}

my $bob = make-turtle();

set-delay($bob, 0.01);

arc($bob, 10, 90);
arc($bob, 20, 90);
arc($bob, 30, 90);
arc($bob, 40, 90);
arc($bob, 50, 90);
arc($bob, 60, 90);
arc($bob, 70, 90);
arc($bob, 80, 90);
arc($bob, 90, 360);

draw-it();

Don’t use a loop. Don’t use a loop. Don’t use a loop. When’s the book going to get to loops?

Encapsulation

Nothing fancy. Just talking about how functions can keep your app tidy.

Generalization

There’s a bit in here about keyword arguments. In Perl 6, it looks like you must specify the arguments that accept keywords:

sub polygon($t, :$length, :$n) {
}

Calling this keyword-enabled polygon looks quite a bit different.

polygon($bob, :length(50), :n(6));

That will take some getting used to. I am so accustomed to hash-style passing in Perl 5 and Ruby. Still, keyword arguments are quite handy for functions that accept a lot of options. I’ll want to revisit them later.

Interface Design

Fine-tuning the logic of circle.

sub circle($t, $r) {
    my $circumference = 2 * $pi * $r;
    my $n = ($circumference / 3).Int + 1;
    my $length = $circumference / $n;
    polygon($t, $length, $n);
}

Refactoring polygon into the more general polyline.

sub polyline($t, $n, $length, $angle) {
    for 1..$n {
        fd($t, $length);
        lt($t, $angle);
    }
}

Changing our shape functions to take advantage of that refactoring.

use v6;
use Swampy;

my $pi = 3.1415926;

sub polyline($t, $n, $length, $angle) {
    for 1..$n {
        fd($t, $length);
        lt($t, $angle);
    }
}

sub polygon($t, $length, $n) {
    my $angle = 360 / $n;
    polyline($t, $n, $length, $angle);
}

sub square($t, $length) {
    polygon($t, $length, 4);
}

sub arc($t, $r, $angle) {
    my $arc-length = 2 * $pi * $r * $angle / 360;
    my $step-count = 30;
    my $step-length = $arc-length / $step-count;
    my $step-angle = $angle / $step-count;
    polyline($t, $step-count, $step-length, $step-angle);
}

sub circle($t, $r) {
    arc($t, $r, 360);
}

my $bob = make-turtle();

set-delay($bob, 0.01);

polyline($bob, 5, 50, 45);
lt($bob, 45);
fd($bob, 100);
polygon($bob, 75, 6);
lt($bob, 45);
square($bob, 100);
lt($bob, 45);
arc($bob, 50, 180);
lt($bob, 45);
circle($bob, 75);

A Development Plan

I’ve heard of those.

Docstring

How about POD?

I’ll keep it simple, since p6doc <filename> doesn’t seem to work as well as perldoc <filename>.

=begin pod

=NAME polygon.p6

=begin DESCRIPTION 

Shape-drawing functions used with Swampy.pm6, written while I read "Think Python"
but write Perl 6.

=end DESCRIPTION

=begin SUBROUTINE C<polyline($t, $n, $length, $angle)>

Draws C<$n> line segements with the given C<$length> and C<$angle>. C<$t> is
a turtle.

=end SUBROUTINE

=end pod

I don’t even know. It would probably be better to stick with the POD notation that is more familiar to Perl 5 folks. Then again, this is mostly for my own entertainment.

Exercises

For these exercises I pretty much just translated the Python code I already had sitting around into Perl 6.

Exercise 4-1

Not much Python-specific here.

Exercise 4-2

Write an appropriately general set of functions that can draw flowers as in Figure 4.1

Just dumping everything into polygon.p6 because I’m in a hurry.

# ...
sub petal($t, $r, $angle) {
    for 1..2 {
        arc($t, $r, $angle);
        lt($t, 180-$angle);
    }
}

sub flower($t, $n, $r, $angle) {
    for 1..$n {
        petal($t, $r, $angle);
        lt($t, 360/$n);
    }
}

sub move($t, $length) {
    pu($t);
    fd($t, $length);
    pd($t);
}

my $bob = make-turtle();
set-delay($bob, 0.01);

move($bob, -100);
flower($bob, 7, 60, 60);
move($bob, 100);
flower($bob, 10, 40, 80);
move($bob, 100);
flower($bob, 10, 140, 20);
draw-it();

Exercise 4-3

Write an appropriately general set of functions that can draw shapes as in Figure 4.2

This one took me a couple of tries, because I forgot a semi-colon. Somewhere a Pythonista is feeling smug.

# ...
sub isosceles($t, $r, $angle) {
    my $y = $r * sin($angle * $pi / 180);

    rt($t, $angle);
    fd($t, $r);

    lt($t, 90+$angle);
    fd($t, 2*$y);

    lt($t, 90+$angle);
    fd($t, $r);

    lt($t, 180-$angle);
}

sub segmented-pie($t, $n, $r) {
    my $angle = 360 / $n;

    for 1..$n {
        isosceles($t, $r, $angle / 2);
        lt($t, $angle);
    }
}

sub draw-pie($t, $n, $r) {
    segmented-pie($t, $n, $r);
    move($t, $r*2 + 10);
}

my $bob = make-turtle();
set-delay($bob, 0.01);

pu($bob);
bk($bob, 130);
pd($bob);

draw-pie($bob, 5, 40);
draw-pie($bob, 6, 40);
draw-pie($bob, 7, 40);
draw-pie($bob, 8, 40);
kill-turtle($bob);
dump-canvas();

draw-it();

Next is an alphabet exercise. I know it will be fairly time consuming, so I will post what I have so far and come back to finish the chapter when I have the time. Right now there is a Mojolicious project I’m supposed to be working on for someone.

It’s just - well - there’s a problem. I don’t think there is a port of the swampy library to Perl 6. I could write one, but that would probably require a Tk interface with Perl 6. Even just writing a Perl 5 Tk version of Swampy is beyond my spare time attention span.

I know what I’ll do. I’ll cheat and have perl6 call python.

$ tar xfvz swampy-2.1.1.tar.gz
$ cd swampy
$ python setup.py build
$ sudo python setup.py install

If you didn’t break your pip like I did the other day, you can probably just pip install swampy.

Right now I’m just shooting for enough to make the first example work. fd and lt need to be implemented, and nothing else.

use v6;

my $turtle = 'turtle';
my @directives;

sub fd($distance) {
    @directives.push("fd($turtle, $distance)");
}

sub lt() {
    @directives.push("lt($turtle)");
}

sub swampy() {
    my $code = @directives.join("\n");

    my $full-code = qq:to/END/;
from swampy.TurtleWorld import *

world = TurtleWorld()
$turtle = Turtle()

$code

wait_for_user()
END

    my $python-file = save-code $full-code;
    say "Python code is in $python-file";
    run-python-with $python-file;
}

sub save-code($code, $name='default.py') {
    my $handle = open $name, :w;
    $handle.say($code);
    $handle.close;

    return $name;
}

sub run-python-with($script) {
    my $python = qx{which python}.chomp;
    my $result = qqx{$python $script}.chomp;

    if $result {
        say "$python output:";
        say $result;
    }
}

fd(100);
lt();
fd(100);
swampy();

Total cheat. I do one-for-one generation of Python Swampy directives from Perl 6, and when everything is generated I create a Python file and hand that off to python. Despite my good intentions of looking for the default Python interpreter, the odds are good that this will only work on my machine.

Even so, I need to make this a module. I don’t want to copy and paste all this every time I want to work through a Swampy example in the book. I’m sticking with a module interface rather than a class so that I can keep the invocation style used in this chapter of Think Python. Also, I’m not entirely certain that I am ready for Perl 6 classes quite yet. Maybe later.

Rather than bore you with details, I’ll send the patient reader to perl6-swampy. This is a simple stupid Perl 6 module that can be downloaded, and then installed with Panda. It probably won’t stay simple for long, but let’s hope it stays stupid. I’m no good with code that’s smarter than I am.

And then the starter code for Chapter 4?

use v6;

use Swampy;

fd(100);
lt();
fd(100);

draw-it();

Yes, I have grand ideas for Swampy.pm6, including crazy stuff like documention. And actual functionality. But hey. It works. I can draw a line and turn left, but in Perl 6. Yay me!

All I had to do was cheat.

Looks pretty much the same. Perl 6 function calls don't require parentheses. Use them or don't. If Perl 5 is anything to go by, not using parens will occasionally have surprising results.

We've already used a lot of method calls. Objects are more fundamental in Perl 6 than in Python, and definitely more than Perl 5. A bit more like Ruby.

Type Conversion

Python has int(var), Perl 6 has $var.Int().

> '32'.Int
32
> 'Hello'.Int
Cannot convert string to number: base-10 number must begin with valid digits or '.' in '⏏Hello' (indicated by ⏏)

Int truncates, not round. We're used to that by now.

 > 3.99999.Int
 3
 > -2.3.Int
 -2

Rat converts integers and strings to Rational numbers, but Perl 6 will generally try to do the right thing if you start doing numbery things to a string.

> '32.1' * 2
64.2

So conversion between numeric types is not important as often in Perl 6.

Math Functions ... Methods ... Callable things

At least some of Python's math functionality is core functionality:

> sin(0.7)
0.644217687237691

... or is is built into the object?

> 0.7.sin
0.644217687237691

I'm not really sure. Maybe both. Maybe neither. Further study on this is a good idea. And as long as I'm thinking about "further study" I may as well find out whether there's a hardcoded constant for π. Not today though.

> my $pi = 3.1415926;
3.1415926
> my $degrees = 45;
45
> my $radians = $degrees / 360 * 2 * $pi;
0.78539815
> sin $radians;
0.707106771713121

Checking the result.

> sqrt(2) / 2;
0.707106781186548

Hm. Really really close, but hm.

Composition

They're just talking about composing expressions from others by using functions.

> my $x = sin( $degrees / 360 * 2 * $pi );
0.707106781186584
> $x = exp(log($x + 1));
1.70710678118658

What does it look like when you try to assign to something that's not okay as an lvalue?

> my $minutes = $hours * 60;
60
> $hours * 60 = $minutes;
Cannot assign to a non-container

Adding new functions

Oh hey. Things started to get interesting.

> sub print-lyrics() {
Unable to parse expression in block; couldn't find final '}'

Hm. Well that's something to look at for the REPL. Anyways. How about creating the function in a file?

use v6;

sub print-lyrics() {
    say "I'm a lumberjack and I'm okay.";
    say "I sleep all night and I work all day."
}

print-lyrics();

Okay maybe not that interesting quite yet.

$ perl6 lyrics.p6
I'm a lumberjack and I'm okay.
I sleep all night and I work all day.

Let's make a simple sub for examining functions.

> sub yo() { say "Yo!" }
sub yo() { ... }
> yo.WHAT
Yo!

Well that doesn't work. It just calls &yo. Oh right. What happens if I use the sigil?

> &yo.WHAT
Sub()

Okay. That works.

Using one function inside another is easy.

> sub yo-yo { yo; yo; }
sub yo-yo() { ... }
> yo-yo
Yo!
Yo!

Definitions and uses

Here's the whole program, Perl 6 style.

use v6;

sub print-lyrics() {
    say "I'm a lumberjack and I'm okay.";
    say "I sleep all night and I work all day."
}

sub repeat-lyrics() {
    print-lyrics();
    print-lyrics();
}

repeat-lyrics();

Exercise 1

Move the last line of this program to the top, so the function call appears before the definitions. Run the program and see what error message you get.

No errors. I removed the parens to see if that caused any change.

use v6;

repeat-lyrics;

sub print-lyrics() {
    say "I'm a lumberjack and I'm okay.";
    say "I sleep all night and I work all day."
}

sub repeat-lyrics() {
    print-lyrics;
    print-lyrics;
}

Nope. It worked smoothly.

Exercise 2

Move the function call back to the bottom and move the definition of print-lyrics after the definition of repeat-lyrics. What happens when you run this program?

What happens is that perl6 runs it as expected without issue. Nothing to see here.

Flow of execution

Bit of common sense advice about following program flow of execution when reading code.

Parameters and arguments

use v6;

sub say-twice($bruce) {
    say $bruce;
    say $bruce;
}

say-twice 'Spam';
say-twice 17;
my $pi = 3.1415926539;
say-twice $pi;

A moment of silence as we enjoy the fact that we can get to function arguments in Perl 6 without unrolling @_ or grabbing a module from CPAN. Okay, moment's over.

$ perl6 say-twice.p6
Spam
Spam
17
17
3.1415926539
3.1415926539

Show that argument is evaluated before being passed to the function.

# ...
say-twice 'Spam ' x 4;

Yep.

...
Spam Spam Spam Spam
Spam Spam Spam Spam

Variables and parameters are local

Variables are available only in their scope.

> sub say-twice($bruce) { say $bruce; say $bruce; }
sub say-twice($bruce) { ... }
> sub cat-twice($part1, $part2) { my $cat = $part1 ~ $part2; say-twice $cat; }
sub cat-twice($part1, $part2) { ... }
> my $line1 = 'Bing tiddle ';
Bing tiddle
> my $line2 = 'tiddle bang.';
tiddle bang.
> cat-twice($line1, $line2);
Bing tiddle tiddle bang.
Bing tiddle tiddle bang.
> say $cat;
Variable $cat is not declared

Not too surprising there.

Stack diagrams

Kind of useful, but the specific example would need to be reworked. Perl 6 catches simple name errors during compilation rather than run time.

> sub say-thrice($bruce) { say $cat }
Variable $cat is not declared

Fruitful functions and void functions

"Fruitful functions" is what the book calls functions with a return value. Again, the specific example works a bit different than in Python.

> my $result = say-twice('Spam')
Spam
Spam
> $result
True
> $result.WHAT
Bool()

say returns a value, say-twice returns the last value generated. In this case, there was no issue. say returned True and so did say-twice.

Why functions?

Explaining the utility of functions from a program architecture perspective.

Importing with from

Hm. It'd be nice to take a moment to think about use, but I'm not sure which modules are okay to import. I'll just leave this one alone for now.

Exercises

Exercise 3

Strings have a method called chars that returns the number of characters in the string, so the value of 'Brian'.chars is 5.

Write a function named right-justify that takes a string named $s as a parameter and prints the string with enough leading spaces so that the last letter of the string is in column 70 of the display.

use v6;
my $name = 'Brian';
say right-justify( $name );

sub right-justify($s) {
    ' ' x (70 - $s.chars) ~ $s;
}

Exercise 4

A function object is a value you can assign to a variable or pass as an argument. For example, do-twice is a function that takes a function object as an argument and calls it twice:

use v6;

sub do-twice(&f) {
    f();
    f();
}

Here's an example that uses do-twice to call a function named say-spam twice:

sub say-spam() {
    say 'spam';
}

do-twice(&say-spam);

1. Type this example into a script and test it.
2. Modify do-twice so that it takes two arguments, a function and a value, and calls the function twice, passing the value as an argument.
3. Write a more general version of say-spam, called say-twice, that takes a string as a parameter and prints it twice.
4. Use the modified version of do-twice to call say-twice twice, passing 'spam' as an argument.
5. Define a new function called do-four that takes a function and a value and calls the function four times, passing the value as a parameter. There should be only two statements in the body of this function, not four.

Exercise 4-2

use v6;

sub do-twice(&f, $arg) {
    f($arg);
    f($arg);
}

sub uc-it($s) {
    say $s.uc;
}

do-twice(&uc-it, 'spam');

Exercise 4-3 and 4-4

use v6;

sub do-twice(&f, $arg) {
    f($arg);
    f($arg);
}

sub say-twice($s) {
    say $s;
    say $s;
}

do-twice(&say-twice, 'spam');

Exercise 4-5

use v6;

sub do-twice(&f, $arg) {
    f($arg);
    f($arg);
}

sub do-four(&f, $arg) {
    do-twice(&f, $arg);
    do-twice(&f, $arg);
}

sub say-twice($s) {
    say $s;
    say $s;
}

do-four(&say-twice, 'spam');

Exercise 5

This exercise can be done using only the statements and other features we have learned so far.

Write a function that draws a grid like the following:

+ - - - - + - - - - +
|         |         |
|         |         |
|         |         |
|         |         |
+ - - - - + - - - - +
|         |         |
|         |         |
|         |         |
|         |         |
+ - - - - + - - - - +

Write a function that draws a similar grid with four rows and four columns.

Exercise 5-1

The challenge in these exercises is not using the basic language structures I'm already familiar with.

use v6;

sub do-twice(&f) {
    f();
    f();
}

sub do-four(&f) {
    do-twice(&f);
    do-twice(&f);
}

sub draw-intersection() {
    print "+ ";
}

sub draw-row-edge() {
    print "- ";
}

sub draw-cell-row-edge() {
    draw-intersection();
    do-four(&draw-row-edge);
}

sub end-line() {
    say;
}

sub draw-grid-row-edge() {
    do-twice(&draw-cell-row-edge);
    draw-intersection();
    end-line();
}

sub draw-column-edge() {
    print "| ";
}

sub draw-cell-space() {
    print "  ";
}

sub draw-cell-spaces() {
    draw-column-edge();
    do-four(&draw-cell-space);
}

sub draw-grid-spaces() {
    do-twice(&draw-cell-spaces);
    draw-column-edge();
    end-line();
}

sub draw-cell-row() {
    draw-grid-row-edge();
    do-four(&draw-grid-spaces);
}

sub draw-grid() {
    do-twice(&draw-cell-row);
    draw-grid-row-edge();
}

draw-grid();

Exercise 5-2

Write a function that draws a similar grid with four rows and four columsn.

I refactored a little bit, but I'm not sure it was actually helpful with the limited toolkit (general programming, not Perl 6) allowed for the reader at this point.

use v6;

sub do-twice(&f) {
    f();
    f();
}

sub do-four(&f) {
    do-twice(&f);
    do-twice(&f);
}

sub do-one-four(&first, &second) {
    first();
    do-four(&second);
}

sub draw-intersection() {
    print "+ ";
}

sub draw-row-edge() {
    print "- ";
}

sub draw-cell-row-edge() {
    do-one-four(&draw-intersection, &draw-row-edge);
}

sub end-line() {
    say;
}

sub draw-grid-row-edge() {
    do-twice(&draw-cell-row-edge);
    draw-intersection();
    end-line();
}

sub draw-column-edge() {
    print "| ";
}

sub draw-cell-space() {
    print "  ";
}

sub draw-cell-spaces() {
    do-one-four(&draw-column-edge, &draw-cell-space);
}

sub draw-grid-spaces() {
    do-twice(&draw-cell-spaces);
    draw-column-edge();
    end-line();
}

sub draw-cell-row() {
    do-one-four(&draw-grid-row-edge, &draw-grid-spaces);
}

sub draw-two-grid() {
    do-twice(&draw-cell-row);
    draw-grid-row-edge();
}

sub draw-four-edge() {
    do-four(&draw-cell-row-edge);
    draw-intersection();
    end-line();
}

sub draw-four-spaces() {
    do-four(&draw-cell-spaces);
    draw-column-edge();
    end-line();
}

sub draw-four-row() {
    do-one-four(&draw-row-edge, &draw-four-spaces);
}

sub draw-four-grid() {
    do-four(&draw-four-row);
    draw-four-edge();
}

draw-four-grid();

Maybe a brief bit about objects in Chapter 1 would be appropriate, because Perl 6 lets you query an object directly about the type associated with a value.

> 'Hello, World!'.WHAT
Str()
> 17.WHAT
Int()
> 3.2.WHAT
Rat()

Strings that have numbers are still strings by default.

> '17'.WHAT
Str()
> '3.2'.WHAT
Str()

Commas make lists.

> 1,000,000
1 0 0

Variables need to be declared - my is a favorite.

> $message = 'And now for something completely different'
Variable $message is not declared
> my $message = 'And now for something completely different'
And now for something completely different

Simple string and number variables are prefixed with $. Perl 6 looks at "type" in at least two ways: the type of a value (Str, Int, Rat, and so on) and the type of the variable that holds the value. For now, just remind folks to declare variables with my and use $ sigil for the variables they're working with at this point.

> my $n = 17;
17
> my $pi = 3.1415926535897932
3.1415926535897932

You can ask a variable what type of value it is holding right now using WHAT.

> $message.WHAT
Str()
> $n.WHAT
Int()
> $pi.WHAT
Rat()

Exercise 1

Perl 6 doesn't actually care about leading zero in a value ordinarily. Caveats about literals in other languages don't apply here, except to remind folks about the difference between Int and Str.

> my $zipcode = 02492;
2492
> $zipcode = '02492';
02492

Rules for variable names are similar to Python and other languages, though that sigil means reserved names aren't such a big deal.

> my $76trombones = 'big parade';
Cannot declare a numeric variable
> my $more@ = 1000000
Two terms in a row
> my $class = 'Advanced Theoretical Zymurgy'
Advanced Theoretical Zymurgy

Note that Perl 6 errors are more descriptive than the infamous "SyntaxError: invalid syntax" of Python.

Oh, and Perl 6 allows - in variable names.

> my $class-name = 'Advanced Theoretical Zymurgy';
Advanced Theoretical Zymurgy

Perl 6 does not do floor division by default. It will convert Int to Rat as needed for an operation.

> my $minute = 59
59
> $minute / 60
0.983333

Use say - remember say? - to get output when running a Perl 6 program as opposed to the interactive shell.

my $miles = 26.2
say $miles * 1.61

Run it.

$ perl6 sample-01.p6
===SORRY!===
Two terms in a row
at sample-01.p6:2
------> <BOL>⏏say $miles * 1.61
    expecting any of:
        postfix
        infix or meta-infix
        infix stopper
        statement end
        statement modifier
        statement modifier loop

Yeah. Better start using semicolons now. Probably should've been using semicolons from the beginning, but I was being lazy. Speaking of lazy, I just noticed that perl6 doesn't seem to require the use v6 pragma. Still, good form is important.

use v6;
my $miles = 26.2;
say $miles * 1.61;

Run it.

$ perl6 sample-01.p6
42.182

That's better.

Assignment lines don't produce output when running outside the REPL.

use v6;
say 1;
my $x = 2;
say $x;

See?

$ perl6 sample-02.p6
1
2

Exercise 2

Type the following statements in the Perl 6 interpreter to see what they do:

5;
my $x = 5;
$x + 1;

Now put the same statements into a script and run it. What is the output? Modify the script by transforming each expression into a say statement and then run it again.

say 5;
my $x = 5;
say $x + 1;

Order of Operations

No huge difference here for simple operations. PEMDAS. When in doubt, use parens.

String Operations

Remember that Perl 6 is still Perl.

> '2' - 1'
1
> 'eggs' / 'easy'
Cannot convert string to number: base-10 number must begin with valid digits or '.' in '⏏eggs' (indicated by ⏏)

Well, almost.

Python concatenates strings with +. Perl 6 concatenates strings with ~.

my $first = 'throat';
my $second = 'warbler';
say $first ~ $second; # says 'throatwarbler'

Python does string repetition with *. Perl 6 does string repetition with x.

> 'spam' x 3
spamspamspam

Comments

# This is a line comment, same as in loads of other languages.

Debugging

Perl 6 error messages are fairly helpful.

> my $bad name = 5;
Two terms in a row

Typos are a common source of errors when caffeine passes the critical threshold. Here is one of the more common typo errors: misspelling a variable name.

> my $principal = 327.68;
327.68
> my $interest = $principle * $rate;
Variable $principle is not declared

Exercises

Exercise 3

Assume that we execute the following assignment statements:

my $width = 17;
my $height = 12.0;
my $delimiter = '.';

For each of the following expressions, write the value of the expression and the type (of the value of the expression).

1. $width / 2 = 8.5 = Rat()
2. $width / 2.0 = 8.5 = Rat() Perl 6 just don't care about floor division
3. $height / 3 = 4 = Rat() Looks like an Int but it's a Rat
4. 1 + 2 * 5 = 11
5. $delimiter x 5 = .....

Use the Perl 6 interpreter to check your answers.

Exercise 4

Practice using the Perl 6 interpreter as a calculator:

Volume of a sphere w/radius r is 4/3πr³. What is the volume of a sphere with radius 5? Python hint doesn't apply.

One solution

 use v6;
 my $radius = 5;
 my $PI = 3.1415926;
 my $area = 4/3 * $pi * $radius**3;
 say $area;

It works.

book cover prices is $24.95, bookstores get 40% discount. Shipping is $3 for first copy and 75 cents per additional copy. What's the total wholesale cost for 60 copies?

Just your basic calculator solution:

 > 24.95 * 0.6 * 60 + 0.75 * (60 - 1) + 3
 945.45

I had to break the next one down carefully, as I am a bear of very small brain.

If I leave my house at 6:52 am and run 1 mile at an easy pace (8:15 per mile), then 3 miles at tempo (7:12 per mile) and 1 mile at easy pace again, what time do I get home for breakfast?

I am willing to bet good money that my solution is more verbose than it needs to be.

use v6;

my $minute = 60;
my $hour = $minute * 60;

# Turn start time to seconds after midnight
my $start-time = (6 * 60 + 52) * 60;
my $easy-pace  = 8 * 60 + 15;
my $tempo-pace = 7 * 60 + 12;
my $running-time = $easy-pace + 3 * $tempo-pace + $easy-pace;
# Find finish time as seconds after midnight
my $finish-time = $start-time + $running-time;

# Convert finish time to a clock time, first in hours:
my $finish-hour = ($finish-time / $hour).Int;
# ... then the seconds left over, expressed as minutes.
my $finish-minute = ($finish-time % $hour / 60).Int;

say "Finish time was $finish-hour:$finish-minute";

That gave me:

$ perl6 jogging.p6
Finish time was 7:30

Just using this space as a public scratchpad at the moment. I've got $RAKUDO_HOME/install/bin on my path to simplify things.

$ perl6 --version
This is perl6 version 2012.12 built on parrot 4.10.0 revision 0

Mostly an explanation of how computer programs work, and bits about the difference between high level and low level languages. Only one actual code sample.

Invoking perl6 without any arguments will start the REPL, shell, interactive mode (call it what you will).

$ perl6
>

Default presentation is a single chevron for user code, and no decoration for output:

> 1 + 1
2

The First Program

say covers the print-with-newline angle. We can use it with or without parentheses.

> say 'Hello, world!';
Hello, world!
> say('Hello, world!');
Hello, world!

But say is also a method attached to objects. Perl 6 literals are objects, too.

> 'Hello, world!'.say;
Hello, world!

Of course, this could lead you down the rabbit hole of explaining objects and literals when the chapter is mostly about "what the heck is a program?" and "how do I get perl6 to do stuff?"

Exercises

If I were actually writing Think Perl 6, the Chapter 1 Exercises would look something like this.

1. Go to the Perl 6 website. This page contains information about Perl 6 and links to pages related to Perl 6. You can also browse a wealth of documentation about Perl 6. not so much on the searching, though
2. It doesn't appear that the perl6 REPL includes a built-in help tool, and the POD does not yet have a perl6toc which ties all the installed documentation together. Best to suggest the doc index for now.
3. Start the perl6 interpreter and use it as a calculator. The Perl 6 syntax for math operations is almost the same as standard mathematical notation

filler line inserted to make Markdown happy

  > 10 / 1.61 # Convert km to miles
  6.211180
  > (43 * 60) + 30 # Convert time to seconds
  2610
  > 2610 / 6.211180 # Average time per mile, in seconds
  420.2100084
  > 420.2100084 / 60 # Average time per mile, in minutes
  7.00350014
  > 60 / 7.00350014 # Miles per hour
  8.5671448277

All this to show that perl6 as a calculator works about the same as python as a calculator, though if you compare to one solution you'll see a difference in the number of significant digits.

I actually have notes for Chapter 2, but my compulsion to begin at the beginning means that this is all I have time for today.

Looks like I made it through Chapter 2

Well, okay. I've been busy playing World of Warcraft, dabbling with languages that are not based on Parrot, and messing about with my laptop. Oh, and doing work stuff. Still, that's kind of busy.

But there are some Parrot things that I'd like to do, and a working parrot-handler could make those things easier. I think maybe a little less WoW and a little more code tonight.

Maybe it's unfair to call it "bad code." It was a result of stress, enthusiasm, or simple ignorance. When I have an outlet for all that energy, my code improves. It shines. It doesn't piddle all over the carpet.

coolnamehere has occasionally served as that outlet, but over the years it has gelled into a tutorial site. It has a specific audience: novice developers who are curious but nervous. It has served that audience well, based on the feedback I get. However, this focus has a cost. Whenever I'm writing something new for coolnamehere, I have to think about my audience. I need to decide if the material is appropriate for them, and figure out ways of presenting it which sweep complexities under the carpet. My own coding skills have atrophied a little as a result. My Perl coding skills have dropped significantly, because I am confident that the best writing about Perl has been written already, or is being written by people much more skillful than myself at both coding and writing.

So here I am. A geek - largely a Perl geek - who has not written more than a few lines of Perl code in a couple of years. What to do?

That is why I signed up for this blog. This will be my outlet to play with big Perl projects with big frameworks, little Perl tasks, and sideways Perl exploration. It will have no focus beyond Perl. Wait. That's a bit of a lie, because "Perl" includes Perl 5, Parrot, Rakudo, and much more. It could even include environment optimizations to make my life as a Perl/Parrot/etc. geek simpler. I'll write about those. Maybe if I can rattle the bits of a few blog entries together, I can come up with more tutorial material for the Perl and Parrot pages at coolnamehere.

Why here rather than continuing on at Blogspot? It boils down to the community. I have always found the Perl community to be especially supportive and encouraging. SPUG and PerlMonks are great groups to associate with, even if I mostly just lurk. I have a strong suspicion that the Perl Blogs will be a welcome extension to that community.

Well, I need to get busy with not-Perl stuff at $work. But at least I have a clear idea why I signed up here, and what I plan to do with this blog in my copious free time. I'm gonna do Perl stuff, write about it, and not worry about whether it would make a good tutorial.