Types and perl language

Types and Perl
Language
hiratara
FreakOut Inc.
Sep. 20, 2013 / YAPC::Asia Tokyo
hiratara Types and Perl Language

What are “types”?
A thing which determines if a
term belong to some class.
1
my $x = "ABC"; $x + 3
sub id { @_ } id(10)
my $f = 0; $f->("X")

Typeable:
1
sub id { @_ } id(10)
Not typeable:
my $x = "ABC"; $x + 3
my $f = 0; $f->("X")

It’s important whether a term is
typeable or not.
It isn’t important what type a term
has.

What is “typeable”?
Is this perl code typeable?
sub add1 {
my $n = $_[0];
return $n + 1;
}

What is “typeable”?
Or, is this C code typeable?
int add1 (int n) {
return n + 1;
}

Considered as the same
sub add1 {
my $n = $_[0];
return $n + 1;
}
int add1 (int n) {
return n + 1;
}

Considered as the same
Perl and C versions of add1 will
be evaluated in the same way. So
the Perl code are as safe as the
C version.
“The same way” means ...

λ calculus
A model of computation
Just a string of symbols
Don’t think what it means

λ calculus
sub add1 {
my $n = $_[0];
return $n + 1;
}
λn.n + 1

λ terms
That’s all.
abstraction λn. ...
application fx

β reduction
(λv.s)t
β
−→ [t → v]s
Example
(λxy.yx)z(λx.x)
β
−→ (λy.yz)(λx.x)
β
−→ (λx.x)z
β
−→ z

Typed λ calculus
Evaluetion is the same with λ
calculus
Give lambda terms typing
rules
Typed terms will be
evaluated correctly
The type wont be changed in
evaluation

Typing rules
x: T ∈ Γ
Γ x: T
Γ, x: T1 t2 : T2
Γ λx: T1.t2 : T1 → T2
Γ t1 : T11 → T12 Γ t2 : T11
Γ t1t2 : T12

example of Typing
x: Int ∈ x: Int, y: Int
x: Int, y: Int x: Int
y: Int ∈ x: Int, y: Int
x: Int, y: Int y: Int
x: Int, y: Int x + y: Int
y: Int λx.x + y: Int → Int
λxy.x + y: Int → Int → Int

How to infer types
....
(λx.x)1: ?
break a problem into 2 parts
building equations, and
solving it.

Building equations
x: T ∈ Γ
Γ x: T|{}
Γ, x: T1 t2 : T2|C
Γ λx: T1.t2 : T1 → T2|C
Γ t1 : X|C1 Γ t2 : T11|C2
Γ t1t2 : T12|C1 ∪ C2 ∪ {X = T11 → T12}

Building equations
We can build equations
recursively.
x: T1 ∈ x: T1
x: T1 x: T1|{}
λx: T1.x: T1 → T1|{} 1: Int|{}
(λx: T1.x)1: T2|{T1 → T1 = Int → T2}

Solving equations
Compare constructors
{X → Y = (Int → Y ) → Y,
X = Y → Y }

Solving equations
X was Int → Y , then, remove X
by substitution
{X = Int → Y , Y = Y,
X = Y → Y }

Solving equations
Remove an equation satisﬁed
X = Int → Y
{Y = Y , Int → Y = Y → Y }

Solving equations
X = Int → Y
{Int → Y = Y → Y }

Solving equations
X = Int → Y
{Int = Y, Y = Y }

Solving equations
X = Int → Int, Y = Int
{Int = Int}

Solving equations
All equetions are satisﬁed :)
X = Int → Int, Y = Int
{}

Infer perl types
Infer the type of
sub { $_[0] + 1 }
The answer is
sub { $_[0] : Int + 1 }
: Int -> Int

Various types
Polymorphic Type
Record Type
Subtype
Recursive Type

Polymorphic Type
Simple typing doesn’t work well
with following terms.
my $id = sub { $_[0] };
$id->("YAPC");
$id->(2013);
Neither $id : Str -> Str nor
$id : Int -> Int.

Universal quantiﬁer
x: T ∈ T, x: T
T, x: T x: T
T λx: T.x: T → T
λT.λx: T.x: ∀T.T → T
(λT.λx: T.x)Int: Int → Int 1: Int
(λT.λx: T.x)Int 1: Int

Let-bound polymorphism
Change the let rule from
Γ t1 : T1 Γ, $x: T1 t2 : T2
Γ my $x =t1; t2 : T2
to
Γ t1 : T1 Γ [$x → t1]t2 : T2
Γ my $x =t1; t2 : T2

Let-bound polymorphism
More practically, ∀ appears only
in the type environment.
Γ, X1, . . . , Xn t1 : T1 Γ, $x: ∀X1 . . . Xn.T1 t2 : T2
Γ my $x =t1; t2 : T2

Record type
Record type is the type for
structures.
{age => 26, name => "Perl"}
: {age: Int, name: String}

Subtyping
{l1 : T1, . . . , lk : Tk, . . . , ln : Tn} <:
{l1 : T1, . . . , lk : Tk}
Si <: Ti
{l1 : S1, . . . , ln : Sn}
<: {l1 : T1, . . . , ln : Tn}

Subtyping
covariant and contravariant
T1 <: S1 S2 <: T2
S1 → S2 <: T1 → T2
For example,
sub { { x => $_[0]->{x} + $_[0]->{x},
y => $_[0]->{x} } }
<:
sub { { x => $_[0]->{x} + $_[0]->{y} } }

Infer subtyping
Subtyping relations are not
equivalence relation but ordering
relation.
It’s non-deterministic to solve
inequality expressions.

row variables
α ⊕ {l1 : T1, . . . , ln : Tn}

row variables
if we have
β ⊕ {l3 : Bool} = α ⊕ {l1 : Int, l2 : Str}
α ⊕ {l1 : Int, l2 : Str} = {l1 : Int, l2 : Str, l3 : Bool}
then
α = {l3 : Bool}
β = {l1 : Int, l2 : Str}

variable arguments
We consider variable arguments
as a record type.
my $plus10 = sub { $_[0] + 10 };
$plus10->(5);
$plus10->(0, "Dummy");

variable arguments
The type of 0, "Dummy" is
{0: Int, 1: Str}, and
$plus10: ∀α.α ⊕ {0: Int} → Int
So α is {1: Str}

Object
Object consists of 2 record types
The record type of ﬁelds, and
The record type of methods

Object
package Language;
sub hello {
my $msg = "I’m " .
$_[0]->{name} .
", Hello.";
print($msg)
}
package main;
my $perl = bless {name => "Perl", age => "26"},
"Language";
$perl->hello();

Object
An instance of Language will
have this subroutine as methods
&Language::hello:
∀αβγ.α ⊕ {0: (β ⊕ {name: Str}, γ)}
→ Unit

Object
$perl:
∀αβγ. (
{name: Str, age: Int},
{hello:
α ⊕ {0: (β ⊕ {name: Str}, γ)}
→ Unit}
)

Invoke methods
$perl->hello() means
Reffer the type of the hello
ﬁeld
Pass $perl as the ﬁrst
argument

Invoke methods
We must solve the following
equation to infer this type.
γ = {hello: α ⊕ {0: (β ⊕ {name: Str}, γ)} → Unit}

Recursive type
The ﬁxed point of types. We
introduce the operator µ .
µX.T = [µX.T → X]T

Recursive types
$perl:
(
{name: Str, age: Int},
µγ.{hello: {0: ({name: Str, age: Int}, γ)}
→ Unit}
}
)

infer recursive types
I wonder if this algorithm is
correct, but it works for me.
X = µX.T if X = T and
X ∈ FV (T)
[µX.T1 → X]T1 = T2 if
µX.T1 = T2 and T1 = X

future work
Subtype
Variant type
Meaningful errors
Support Hashes and Arrays
Use external Parser

Types and perl language

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (20)

Similar a Types and perl language

Similar a Types and perl language (20)

Último

Último (20)

Types and perl language