## Posts Tagged ‘constraints’

### Day 8: .comb your constraints

December 8, 2009

We have hit the point where the previous gifts are useful for the current gifts. Today is a dual set: the `comb` method and the idea of constraints.

Similar to the static types previous defined, constraints allow fine control in writing subroutines and methods. In many other programming languages, you have to pass parameters into a subroutine and then validate the input that comes in. With constraints, you can do the validation right in the declaration.

Take this basic example. If the integer is even, I don’t want to deal with this subroutine. In Perl 5, it would be written something similar to this:

```sub very_odd
{
my \$odd = shift;
unless (\$odd % 2)
{
return undef;
}
# Process the odd number here.
}
```

In Perl 6, this can be simplified thusly:

```sub very_odd(Int \$odd where {\$odd % 2})
{
# Process the odd number here
}
```

If you attempt to call very_odd with an even number, you will get an error. Do not fret though: you can use the multi sub functionality to give even numbers a chance to shine…maybe. ;)

```multi sub very_odd(Int \$odd where {\$odd % 2})
{
# Process the odd number here
}
multi sub very_odd(Int \$odd) { return Bool::False; }
```

These constraints can be useful when paired with the `.comb` method. What exactly is `.comb`? For those that brush their own hair, you generally use a comb to get the strands you want and settle them somewhere on your head. For those that like using `.split`, it’s the opposite: instead of separating a `Str` by what you don’t want, you separate it by what you do. This simple piece of code should demonstrate that:

```say "Perl 6 Advent".comb(/<alpha>/).join('|');
say "Perl 6 Advent".comb(/<alpha>+/).join('|');
```

Regex patterns will most likely be covered another day, but a quick preview won’t hurt. The first line will print `P|e|r|l|A|d|v|e|n|t`: it gets every alphabetic character and puts it into a temporary array. It is then joined together with the pipe character. The second line is similar, only it grabs as many alphabetic characters as it can, resulting in `Perl|Advent`.

The power of `.comb` is much more, however. Once you have combed out what you wanted, you can manipulate the strands. If you have a basic string of ASCII hex characters, you can use the hyperoperators to change each piece into the ASCII equivalent!

```say "5065726C36".comb(/<xdigit>**2/)».fmt("0x%s")».chr
# Outputs "Perl6"
```

For those intimidated by that, you can find also use the `.map` method.

```say "5065726C36".comb(/<xdigit>**2/).map: { chr '0x' ~ \$_ } ;
# Outputs "Perl6"
```

Remember, this is Perl. There is more than one way to do it. ☺

With all of the gifts that have been presented today, I now have a challenge for all of you. With the assistance of Kyle Hasselbacher, I was able to make a decent version of the ancient Caesar Cipher using constraints, `.comb`, and the old style `.map`.

```use v6;

sub rotate_one( Str \$c where { \$c.chars == 1 }, Int \$n ) {
return \$c if \$c !~~ /<alpha>/;
my \$out = \$c.ord + \$n;
\$out -= 26 if \$out > (\$c eq \$c.uc ?? 'Z'.ord !! 'z'.ord);
return \$out.chr;
}

sub rotate(Str \$s where {\$s.chars}, Int \$n = 3)
{
return (\$s.comb.map: { rotate_one( \$_, \$n % 26 ) }).join( '' );
}

die "Usage:\n\$*PROGRAM_NAME string number_for_rotations" unless @*ARGS == 2;

my Str \$mess = @*ARGS[0];
my Int \$rotate = @*ARGS[1].Int;

say qq|"\$mess" rotated \$rotate characters gives "{rotate(\$mess,\$rotate)}".|;

```

I would like to see how the rest of you can code this algorithm using Perl 6 and the gifts so far. After all, the language can only get better with more usage.