Introdução ao Perl 6

Introdução ao Perl 6
@that_garu

Perl, reescrito pela
própria comunidade.

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

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

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;
}

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;
}

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

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

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

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

say “c[DROMEDARY CAMEL]"
🐪

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

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

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

my @paises = qw{Brasil Chile};

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

say @paises[^2]
(Brasil Chile)

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

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

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

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

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

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

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

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

say %capitais{‘Brasil'}
Brasília

say %capitais<Brasil>
Brasília

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

if / elsif / else / unless 
given - when

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

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

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

my $dados = slurp ‘arquivo.txt'

spurt ‘arquivo.txt’, $dados

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

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

 
for $fh.lines { 
.say if /abc/; 
}

 
.say if /abc/ for $fh.lines;

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

sub oi (Str $nome) { 
}

sub oi (Str $nome = 'Anônimo') { 
}

sub oi (Str $nome where *.chars > 0) { 
}

subset NonEmptyStr of Str where *.chars > 0; 
 
sub oi (NonEmptyStr $nome) { 
}

 
sub oi (NonEmptyStr $nome) is cached { 
}

 
sub oi (NonEmptyStr $nome) returns Str { 
}

 
sub oi (NonEmptyStr $nome) is cached returns Str { 
}

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

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

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

ﬁzzbuzz 
sem condicionais?

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

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]

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

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

class Point { 
has Real $.x is rw = 0; 
has Real $.y is rw = 0;
} 
 
 
 
say “$ponto" # [4,7] 
$ponto.y = -1; 
say “$ponto" # [4,-1]

class Point { 
subset Limitado of Real where -10 <= * <= 10; 
has Limitado $.x is rw = 0; 
has Limitado $.y is rw = 0;
} 
 
 
say “$ponto" # [4,7] 
$ponto.y = -1; 
say “$ponto" # [4,-1]

class Point { 
subset Limitado of Real where -10 .. 10; 
} 
 
 
say “$ponto" # [4,7] 
$ponto.y = -1; 
say “$ponto" # [4,-1]

class Point { 
subset Limitado where -10.0 .. 10.0; 
} 
 
 
say “$ponto" # [4,7] 
$ponto.y = -1; 
say “$ponto" # [4,-1]

class Point { 
has Limitado $.x is rw = die ‘x is required'; 
has Limitado $.y is rw = die ‘y is required';
} 
 
 
say “$ponto" # [4,7] 
$ponto.y = -1; 
say “$ponto" # [4,-1]

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

class Point { 
}
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)

class Point { 
}
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)

class Point { 
}
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++

class Point { 
}
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

class Point { 
}
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

class Point { 
}
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

class Point { 
}
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

class Point { 
}
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

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

Obrigado!
Dúvidas?
@that_garu

Créditos e informações adicionais
Carl Mäsak - ﬁzzbuzz.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

Introdução ao Perl 6

More Related Content

What's hot (20)

Similar to Introdução ao Perl 6 (20)

More from garux (14)

Recently uploaded (20)

Introdução ao Perl 6