Conheça um pouco mais sobre Perl 6, uma linguagem de programação moderna, poderosa e robusta que permitirá que você escreva código de forma ágil e eficiente.

1. Introdução ao Perl 6
@that_garu

2. Perl 6

3. Perl, reescrito pela
própria comunidade.

4. Um novo Perl

5. mais moderno

6. mais amigável

7. mais poderoso

8. mais correto

9. mais seguro

10. Instalando

11. git clone https://github.com/tadzik/rakudobrew ~/.rakudobrew
export PATH=~/.rakudobrew/bin:$PATH
rakudobrew init
rakudobrew build moar
rakudobrew build-panda
panda install Linenoise

12. Números

13. 6

14. say 6

15. say 6
6

16. say 6.WHAT

17. say 6.WHAT
(Int)

18. 6.0

19. 6.029e4

20. say 6.029e4.WHAT
say 6.WHAT
say 6.0.WHAT
(Int)
(Rat)
(Num)

21. say 7/2

22. say 7/2
3.5

23. Ruby
puts 7/2
Python 2
print 7/2
JavaScript
console.log(7/2)
C
#include <stdio.h>
int main (void) {
printf(“%f”, 7/2);
return 0;
}

24. Ruby
puts 7/2
3
Python 2
print 7/2
3
JavaScript
console.log(7/2)
3.5
C
WARNING: argument has type ‘int'
0.0000
#include <stdio.h>
int main (void) {
printf(“%f”, 7/2);
return 0;
}

25. Ruby
puts 7/2
3
Python 2
print 7/2
3
JavaScript
console.log(7/2)
3.5
C
#include <stdio.h>
int main (void) {
printf(“%d”, 7/2);
return 0;
}
3

26. say .1 + .2 - .3

27. say .1 + .2 - .3
0

28. Ruby
puts 0.1 + 0.2 - 0.3
Python 2
print .1 + .2 - .3
JavaScript
console.log(.1 + .2 - .3)
Perl 5
say .1 + .2 - .3

29. Ruby
puts 0.1 + 0.2 - 0.3
5.551115123125783e-17
Python 2
print .1 + .2 - .3
5.55111512313e-17
JavaScript
console.log(.1 + .2 - .3)
Perl 5
5.551115123125783e-17
say .1 + .2 - .3
5.55111512312578e-17

30. say 7.2.numerator
36
say 7.2.denominator
5
say 7.2.nude
(36 5)
say 36/5
7.2

31. Números

32. ೬

33. say ೬.WHAT
(Int)

34. say ೬ + 1
7

36. Strings

37. say “Alô, YAPC"

38. say 'Alô, YAPC'

39. say ｢Alô, YAPC｣

40. say q|Alô, YAPC|

41. say ‘YA’ ~ ‘PC’
YAPC

42. say uc(‘yapc’)
YAPC

43. say ‘yapc’.uc
YAPC

44. say “c[DROMEDARY CAMEL]"
🐪

45. say ‘🐪’
🐪

46. say ‘🐪’.chars
1

47. ‘YAPC::BR’.ends-with(‘BR')
True

48. Variáveis

49. my $var

50. say $var.WHAT
(Any)

51. my Int $var

52. say $var.WHAT
(Int)

53. my $resposta = 42

54. say $resposta.WHAT
(Int)

55. my @paises = (
‘Brasil’,
‘Chile’
);

56. my @paises =
‘Brasil’,
‘Chile’
;

57. my @paises = qw{Brasil Chile};

58. my @paises = <Brasil Chile>;

59. my @paises = <<
Brasil
Chile
“Reino Unido"
>>;

60. say @paises.elems
3

61. say @paises[0]
Brasil

62. say @paises[*-1]
Reino Unido

63. say @paises[^2]
(Brasil Chile)

64. say 0...10
(0 1 2 3 4 5 6 7 8 9 10)

65. say 0,2...10
(0 2 4 6 8 10)

66. say 2, 4, 8...100
(2 4 8 16 32 64)

67. my @lazy = 2, 4, 8...*;
say @lazy[20]
2097152

68. my @primes = grep { .is-prime }, 1..*;
say @primes[^10]
(2 3 5 7 11 13 17 19 23 29)

69. my @fib = 0, 1, * + * ... *;
say @fib[^10]
(0 1 1 2 3 5 8 13 21 34)

70. my %capitais = (
‘Brasil' => ‘Brasília',
‘Chile' => ‘Santiago’,
);

71. my %capitais =
‘Brasil' => ‘Brasília',
‘Chile' => ‘Santiago’,
;

72. say %capitais.elems
2

73. say %capitais{‘Brasil'}
Brasília

74. say %capitais<Brasil>
Brasília

75. say %capitais< Brasil Chile >
(Brasília Santiago)

76. %capitais<Brasil>:exists
True

77. Condicionais

78. if / elsif / else / unless
given - when

79. if ($x < 10) {
...
}

80. if $x < 10 {
...
}

81. if 5 < $x < 10 {
...
}

82. say $x unless 5 < $x < 10

83. Laços

84. foreach

85. while ($x < 10) {
...
}

86. while $x < 10 {
...
}

87. until $x < 10 {
...
}

88. while (1) {
...
}

89. loop {
...
}

90. loop (my $x = 0; $x < 10; $x++) {
...
}

91. for @capitais -> $cidade {
...
}

92. for ^10 -> $n1, $n2 {
...
}

93. I/O

94. my $nome = prompt “nome:"

95. my $dados = slurp ‘arquivo.txt'

96. spurt ‘arquivo.txt’, $dados

97. my @linhas = ‘arquivo.txt’.IO.lines

98. my $fh = open ‘arquivo.txt’;
for $fh.lines -> $line {
say $line if $line ~~ /abc/;
}

99. my $fh = open ‘arquivo.txt’;
for $fh.lines {
.say if /abc/;
}

100. my $fh = open ‘arquivo.txt’;
.say if /abc/ for $fh.lines;

101. funções

102. sub oi ($nome) {
return “oi, $nome!";
}

103. sub oi (Str $nome) {
return “oi, $nome!";
}

104. sub oi (Str $nome = 'Anônimo') {
return “oi, $nome!";
}

105. sub oi (Str $nome where *.chars > 0) {
return “oi, $nome!";
}

106. subset NonEmptyStr of Str where *.chars > 0;
sub oi (NonEmptyStr $nome) {
return “oi, $nome!";
}

107. subset NonEmptyStr of Str where *.chars > 0;
sub oi (NonEmptyStr $nome) is cached {
return “oi, $nome!";
}

108. subset NonEmptyStr of Str where *.chars > 0;
sub oi (NonEmptyStr $nome) returns Str {
return “oi, $nome!";
}

109. subset NonEmptyStr of Str where *.chars > 0;
sub oi (NonEmptyStr $nome) is cached returns Str {
return “oi, $nome!";
}

110. sub dobra (Int $num) {
return $num * 2;
}

111. multi dobra (Int $num) {
return $num * 2;
}

112. multi dobra (Int $num) {
return $num * 2;
}
multi dobra (Str $palavra) {
return $palavra x 2;
}

113. fizzbuzz
sem condicionais?

114. sub fizzbuzz($n) {
multi case($, $) { $n }
multi case(0, $) { “fizz" }
multi case($, 0) { “buzz" }
multi case(0, 0) { "fizzbuzz" }
case $n % 3, $n % 5;
}

115. classes

116. class Point {
has $.x = 0;
has $.y = 0;
method Str { “[$.x,$.y]” }
}
my $ponto = Point.new(x => 4,y => 7);
say $ponto.x; # 4
say $ponto.y; # 7
say “$ponto" # [4,7]

117. class Point {
has $.x = 0;
has $.y = 0;
method Str { “[$.x,$.y]” }
method set (:$x = $.x, :$y = $.y) {
$!x = $x; $!y = $y;
}
}
my $ponto = Point.new(x => 4,y => 7);
say “$ponto" # [4,7]
$ponto.set( y => -1 );
say “$ponto" # [4,-1]

118. class Point {
has Real $.x = 0;
has Real $.y = 0;
method Str { “[$.x,$.y]” }
method set (:$x = $.x, :$y = $.y) {
$!x = $x; $!y = $y;
}
}
my $ponto = Point.new(x => 4,y => 7);
say “$ponto" # [4,7]
$ponto.set( y => -1 );
say “$ponto" # [4,-1]

119. class Point {
has Real $.x is rw = 0;
has Real $.y is rw = 0;
method Str { “[$.x,$.y]” }
}
my $ponto = Point.new(x => 4,y => 7);
say “$ponto" # [4,7]
$ponto.y = -1;
say “$ponto" # [4,-1]

120. class Point {
subset Limitado of Real where -10 <= * <= 10;
has Limitado $.x is rw = 0;
has Limitado $.y is rw = 0;
method Str { “[$.x,$.y]” }
}
my $ponto = Point.new(x => 4,y => 7);
say “$ponto" # [4,7]
$ponto.y = -1;
say “$ponto" # [4,-1]

121. class Point {
subset Limitado of Real where -10 .. 10;
has Limitado $.x is rw = 0;
has Limitado $.y is rw = 0;
method Str { “[$.x,$.y]” }
}
my $ponto = Point.new(x => 4,y => 7);
say “$ponto" # [4,7]
$ponto.y = -1;
say “$ponto" # [4,-1]

122. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = 0;
has Limitado $.y is rw = 0;
method Str { “[$.x,$.y]” }
}
my $ponto = Point.new(x => 4,y => 7);
say “$ponto" # [4,7]
$ponto.y = -1;
say “$ponto" # [4,-1]

123. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
method Str { “[$.x,$.y]” }
}
my $ponto = Point.new(x => 4,y => 7);
say “$ponto" # [4,7]
$ponto.y = -1;
say “$ponto" # [4,-1]

124. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
}
my $ponto = Point.new(x => 4,y => 7);
$ponto.y = -1;
say $ponto.perl # Point.new(x => 4, y => -1)

125. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
}
Perl 6
package Point {
use Carp;
use overload '""' => &Str, fallback => 1;
sub _pointlimit {
my ( $class, $num ) = @_;
unless ( $num >= -10 && $num <= 10 ) {
croak "...";
}
}
sub new {
my ( $class, $x, $y ) = @_;
my $self = bless { x => undef, y => undef } => $class;
$self->x($x);
$self->y($y);
return $self;
}
sub x {
my ( $self, $x ) = @_;
$self->_pointlimit ($x);
$self->{x} = $x;
}
sub y {
my ( $self, $y ) = @_;
$self->_pointlimit ($y);
$self->{y} = $y;
}
sub Str {
my $self = shift;
return sprintf "[%f,%f]" => $self->x, $self->y;
}
}
Perl 5 (core)

126. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
}
Perl 6
package Point {
use Moose;
use overload '""' => &Str, fallback => 1;
use Moose::Util::TypeConstraints;
subtype "PointLimit" => as 'Num'
=> where { $_ >= -10 && $_ <= 10 }
=> message { "$_ must be a Num between -10 and 10, inclusive" };
has [qw/x y/] => (
is => 'rw',
isa => 'PointLimit',
required => 1,
);
sub Str {
my $self = shift;
return sprintf "[%f,%f]" => $self->x, $self->y;
}
}
Perl 5 (Moose)

127. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
}
Perl 6
#include <iostream>
#include <sstream>
class Point {
double x_, y_;
public:
Point (double x, double y) : x_(constrain(x)), y_(constrain(y)) {}
double x () const { return x_; }
double y () const { return y_; }
void x (double num) { x_ = constrain(num); }
void y (double num) { y_ = constrain(num); }
friend std::ostream & operator<< (std::ostream & stream, const Point & point) {
stream << '[' << point.x() << ',' << point.y() << ']';
return stream;
}
private:
static double constrain (double num) {
if (num < -10 || num > 10) {
std::stringstream ss;
ss << "'" << num << "' is not a real number between -10 and 10, inclusive";
throw(ss.str());
}
return num;
}
};
C++

128. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
}
Perl 6
public class Point {
private static final double X_MIN = -10.0, X_MAX = 10.0;
private static final double Y_MIN = -10.0, Y_MAX = 10.0;
private double x, y;
public Point(double x, double y) throws IllegalArgumentException {
setX(x);
setY(y);
}
public double getX() { return x; }
public double getY() { return y; }
public void setX(double x) throws IllegalArgumentException {
if (x < X_MIN || x > X_MAX)
throw new IllegalArgumentException("...");
this.x = x;
}
public void setY(double y) throws IllegalArgumentException {
if (y < Y_MIN || y > Y_MIN)
throw new IllegalArgumentException("...");
this.y = y; }
@Override
public String toString() {
return String.format("[%.1f,%.1f]", x, y);
}
}
Java

129. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
}
Perl 6
class PointLimit:
def __init__(self, name):
self.name = name
def __get__(self, point, owner):
return point.__dict__.get(self.name)
def __set__(self, point, value):
if not -10 < value < 10:
raise ValueError('Value %d is out of range' % value)
point.__dict__[self.name] = value
class Point:
x = PointLimit('x');
y = PointLimit('y');
def __init__(self, x, y):
self.x = x
self.y = y
def __str__(self):
return "[%f,%f]" % (self.x, self.y)
Python 3

130. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
}
Perl 6
function definePointLimit(point, name) {
Object.defineProperty(point, name, {
set: function (value) {
if (value < -10 || value > 10)
throw 'Value ' + value + ' is out of range';
point['_' + name] = value;
},
get: function () {
return point['_' + name];
}
});
}
function Point(x, y) {
definePointLimit(this, 'x');
definePointLimit(this, 'y');
this.x = x;
this.y = y;
}
Point.prototype.toString = function() {
return '[' + this.x + ',' + this.y + ']';
}
JavaScript

131. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
}
Perl 6
class Point
POINT_RANGE = -10..10
attr_constrained x: POINT_RANGE, y: POINT_RANGE
def initialize
@x = 0
@y = 0
end
def to_s
"[#{x},#{y}]"
end
private
def self.attr_constrained(attrs_and_constraints)
attrs_and_constraints.each do |attr, constraint|
attr_reader attr
define_method(:"#{attr}=") do |value|
raise "#{value} is not a valid value for #{attr}"
unless constraint === value
instance_variable_set :"@#{attr}", value
end
end
end
end
Ruby

132. class Point {
subset Limitado where -10.0 .. 10.0;
has Limitado $.x is rw = die ‘x is required';
has Limitado $.y is rw = die ‘y is required';
}
Perl 6
package point
import "fmt"
import "errors"
type Point struct {
x, y float64
}
func NewPoint(x, y float64) (*Point, error) {
p := &Point{x, y}
if !IsValid(x) {
return nil, errors.New("Point x out of range!”)
}
if !IsValid(y) {
return nil, errors.New("Point y out of range!”)
}
return p, nil
}
func IsValid(p float64) (result bool) {
if p >= -10 && p <= 10 {
result = true
}
return
}
func (p *Point) String() string {
return fmt.Sprintf("[%v,%v]", p.x, p.y)
}
func (p *Point) SetX(x float64) (float64, error) {
ox := p.x
if !IsValid(x) {
return ox, errors.New("Point out of range!")
}
return ox, nil
}
func (p *Point) SetY(y float64) (float64, error) { oy := p.y
if !IsValid(y) {
return oy, errors.New("Point out of range!")
}
return oy, nil
}
func (p *Point) GetX() float64 {
return p.x
}
func (p *Point) GetY() float64 {
return p.y
}
Go

133. CLI
async
gramáticas
exceções MOP
Native Calling
junctions

134. docs.perl6.org

135. Obrigado!
Dúvidas?
@that_garu

136. Créditos e informações adicionais
Carl Mäsak - fizzbuzz.p6:
https://gist.github.com/masak/b9371625ad85cfe0faba
Jonathan Worthington - Perl 6 hands-on tutorial
http://jnthn.net/papers/2015-spw-perl6-course.pdf
Curtis “Ovid" Poe - Perl 6 for mere mortals
http://www.slideshare.net/Ovid/perl-6-for-mere-mortals