Types and perl language

Types and PerlLanguage

hirataraFreakOut Inc.

Sep. 20, 2013 / YAPC::Asia Tokyo

hiratara Types and Perl Language

What are “types”?

A thing which determines if aterm 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 istypeable or not.It isn’t important what type a termhas.


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


}

int add1 (int n) {return n + 1;

}


Considered as the same

Perl and C versions of add1 willbe evaluated in the same way. Sothe Perl code are as safe as theC version.“The same way” means ...


λ calculus

A model of computationJust a string of symbolsDon’t think what it means


λ calculus


}

λn.n + 1


λ terms

That’s all.

abstraction λn. ...application fx


β reduction

(λv.s)tβ−→ [t 7→ v]s

Example

(λxy.yx)z(λx.x)β−→ (λy.yz)(λx.x)β−→ (λx.x)z

β−→ z


Typed λ calculusEvaluetion is the same with λcalculusGive lambda terms typingrulesTyped terms will beevaluated correctlyThe type wont be changed inevaluation


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 partsbuilding equations, andsolving 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 equationsrecursively.

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 Xby substitution

{X = Int→ Y , Y = Y,

X = Y → Y }


Solving equations

Remove an equation satisfied

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 satisfied :)

X = Int→ Int, Y = Int

{}


Infer perl typesInfer the type of

sub { $_[0] + 1 }

The answer is

sub { $_[0] : Int + 1 }: Int -> Int


Various types

Polymorphic TypeRecord TypeSubtypeRecursive Type


Polymorphic TypeSimple typing doesn’t work wellwith following terms.

my $id = sub { $_[0] };$id->("YAPC");$id->(2013);

Neither $id : Str -> Str nor$id : Int -> Int.


Universal quantifier

x : T ∈ T, x : TT, 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 polymorphismChange 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 onlyin 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 forstructures.

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


Subtypingcovariant 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 notequivalence relation but orderingrelation.It’s non-deterministic to solveinequality expressions.


row variables

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


row variablesif 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 argumentsas 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 typesThe record type of fields, andThe 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 willhave 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 hellofieldPass $perl as the firstargument


Invoke methods

We must solve the followingequation to infer this type.

γ = {hello : α⊕ {0: (β ⊕ {name : Str}, γ)} → Unit}


Recursive type

The fixed point of types. Weintroduce the operator µ .

µX.T = [µX.T 7→ X ]T


Recursive types

$perl :

(

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

)


infer recursive types

I wonder if this algorithm iscorrect, but it works for me.

X = µX.T if X = T andX ∈ FV (T )

[µX.T1 7→ X ]T1 = T2 ifµX.T1 = T2 and T1 6= X


future work

SubtypeVariant typeMeaningful errorsSupport Hashes and ArraysUse external Parser


Types and perl language

Technology

Transcript of Types and perl language