This is the second report on TyCO, a (still) experimental strongly and implicitly typed concurrent object oriented programming language based on a predicative polymorphic calculus of objects, featuring asynchronous messages, objects, and process declarations, together with a predicative polymorphic type syste

Bastos, Rui

Vasconcelos, Vasco T.

Portuguese

Repositório da Universidade de Lisboa

Core-TyCO, The Language Definition, Version 0.1

Universidade de Lisboa: Repositório.UL

Core-TyCOThe Language DefinitionVersion 0.1Vasco T. VasconcelosRui BastosDI–FCUL TR–98–3March 1998Departamento de InformáticaFaculdade de Ciências da Universidade de LisboaCampo Grande, 1700 LisboaPortugalTechnical reports are available at http://www.di.fc.ul.pt/biblioteca/tech-reports.The files are stored in PDF, with the report number as filename. Alternatively, reportsare available by post from the above address.This is the second report on TyCO [3], a (still) experimental strongly andimplicitly typed concurrent object oriented programming language based on apredicative polymorphic calculus of objects [4, 5], featuring asynchronous mes-sages, objects, and process declarations, together with a predicative polymor-phic typing assignment system assigning monomorphic types to variables andpolymorphic types to process variables.Sections 1 and 2 define the syntax and static semantics of the language, bothin the style of Standard ML [2]. Dynamic semantics is the subject of Section 3,presented along the lines of the π-calculus [1].Contents1 Syntax 11.1 Reserved words . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2 Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3 Grammar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.4 Syntactic restrictions . . . . . . . . . . . . . . . . . . . . . . . . . 41.5 Comments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.6 Derived forms for processes . . . . . . . . . . . . . . . . . . . . . 42 Static semantics 42.1 Simple objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42.2 Compound objects . . . . . . . . . . . . . . . . . . . . . . . . . . 42.3 Operations on finite maps . . . . . . . . . . . . . . . . . . . . . . 42.4 Recursive types, infinite trees, and typing compatibility . . . . . 52.5 Free type variables . . . . . . . . . . . . . . . . . . . . . . . . . . 52.6 Type schemes, closure, and instances . . . . . . . . . . . . . . . . 52.7 Environment modification and projection . . . . . . . . . . . . . 52.8 Derived forms for types . . . . . . . . . . . . . . . . . . . . . . . 62.9 Types for primitive operations and objects . . . . . . . . . . . . . 62.10 Inference rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Dynamic semantics 93.1 Free identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93.2 Variable substitution and α-conversion . . . . . . . . . . . . . . . 103.3 Structural congruence . . . . . . . . . . . . . . . . . . . . . . . . 103.4 Reduction rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 Syntax1.1 Reserved wordsFigure 1 lists the reserved words of core-TyCO. They may not be used asidentifiers.1and branch def else if in inactioninto let new not or then! ? | { } [ ] ( ) , _+ - * / % = <> > >= < <= ^Figure 1: Reserved Wordsc or const ∈ Const constants (Integer, Boolean, and String)a, x or var ∈ Var variablesv or val ∈ Const ∪Var valuesl or label ∈ Label labelsX or procvar ∈ ProcVar process variablesFigure 2: Classes of Identifiers1.2 IdentifiersThe classes of identifiers for core-TyCO are shown in Figure 2.An integer constant (decimal notation only) is an optional negation symbol(-) followed by a non-empty sequence of decimal digits 0–9. A boolean constantis either true or false. A string constant is a sequence, between quotes ("), ofzero or more characters.1.3 GrammarThe phrase classes for core-TyCO are shown in Figure 3 and the grammaticalrules in Figure 4. Brackets 〈 〉 enclose optional phrases.program ∈ Program programsP , Q, R or proc ∈ Proc processesD or dec ∈ Dec declarationsbind ∈ Bind process bindingsmultbind ∈ MultBind sequence of bindingsM or method ∈ Method methodsM+ or methrow ∈ MethRow method rowse or exp ∈ Exp expressionsexpseq ∈ Exp+ sequence of expressionsvarseq ∈ Var+ sequence of variablesvalseq ∈ Val+ sequence of valuesbinop ∈ BinOp binary operatorsunop ∈ UnOp unary operatorsFigure 3: Phrase ClassesThe scope of new extends as far to the right as possible, and the operator |takes precedence over def–in, so, for example, def D in new x P | Q meansdef D in (new x (P | Q)). The precedence and associativity of the remainingoperators (including arithmetical and logical) is standard.2program ::= proc programproc ::= var ! label [ 〈expseq〉 ] messagevar ? { 〈methrow〉 } objectnew var proc scope restrictiondef dec in proc local declarationprocvar [ 〈expseq〉 ] process instantiationproc | proc parallel compositionif exp then proc else proc conditionalinaction inaction( proc )dec ::= multbind sequence of bindingsmultbind ::= bind 〈and multbind〉 multiple bindingbind ::= procvar ( 〈varseq〉 ) = proc process bindingmethrow ::= method 〈, methrow〉 method rowmethod ::= label ( 〈varseq〉 ) = proc methodexp ::= exp binop exp infixed expressionunop exp prefixed expressionval value( exp )expseq ::= exp 〈, expseq〉 sequence of expressionsvarseq ::= var 〈, varseq〉 sequence of variablesbinop ::= + | - | * | / | % | ^ |= | <> | > | >= | < | <= |and | orunop ::= - | notFigure 4: Grammar31.4 Syntactic restrictions1. No label may appear twice in the same method row.2. No method or process binding parameter list may contain the same vari-able twice.3. No sequence of bindings may contain the same process variable twice.1.5 CommentsA comment is any character sequence beginning with -- and extending to theend of the same line.1.6 Derived forms for processesA list of derived forms built from the primitives of the core language is shownin Figure 5, where variable z is fresh. Symbol =⇒ means ‘rewrites to’.2 Static semantics2.1 Simple objectsThe simple objects for the static semantics are defined in Figure 6.2.2 Compound objectsWhen A and B are sets, A 7→ B denotes the set of finite maps (partial functionswith finite domain) from A to B. The domain of a finite map f is denoteddom(f).Figure 7 shows the compound objects for the static semantics.2.3 Operations on finite mapsA finite map will often be written explicitly in the form {a1 : b1, . . . , an : bn},for n ≥ 0; in particular, the empty map is {}. When an = a1 · · ·an andbn = b1 · · · bn, we abbreviate the above finite map to {an : bn}.When f and g are finite maps, the map f + g, called f modified by g, is thefinite map with domain dom(f) ∪ dom(g) and values(f + g)(a) = if a ∈ dom(g) then g(a) else f(a).When f is a finite map and A a set, f \ A, called f restricted by A, is thefinite map with domain dom(f) \A and values(f \A)(a) = f(a).42.4 Recursive types, infinite trees, and typing compatibil-ityTypes are interpreted as regular infinite trees. A translation ()∗ from types toinfinite trees is defined as follows.t∗ = t%∗ = {l : α∗1 · · ·α∗n | l : α1 · · ·αn ∈ %}µt.α∗ = fix(λρ.α∗[ρ/t])Two types α and β are equivalent, denoted by α ≈ β, iff α∗ = β∗. Twotypings Γ and ∆ are compatible, denoted by Γ  ∆, iff whenever a ∈ dom(Γ) ∩dom(∆) then Γ(a) ≈ ∆(a). Similarly, two record types % and %′ are compatible,%  %′, iff whenever l ∈ dom(%)∩dom(%′) then %(l) = α1 · · ·αn, %′(l) = β1 · · ·βn,and αi ≈ βi, for 1 ≤ i ≤ n.2.5 Free type variablesThe set of free type variables in the various semantic objects is inductivelydefined as follows.ftv(t) = {t}ftv(α1 · · ·αn) =⋃1≤i≤n ftv(αi)ftv(µt.α) = ftv(α) \ {t}ftv(∀tn.τ) = ftv(τ) \ {tn}ftv(f) =⋃a∈dom(f) ftv(a) (for f a finite map)2.6 Type schemes, closure, and instancesTwo type schemes are considered equal if they can be obtained from each otherby renaming and reordering of bound type variables, and deleting type variablesfrom the prefix which do not occur in the body.A type scheme σ = ∀tn.τ generalizes another type scheme σ′ = ∀un.τ ′,written σ  σ′, if τ ′ = τ [αn/tn], for some αn, and un contains no free typevariables of σ.Let τ be a sequence of types and E an environment. The closure of τ withrespect to E, closE(τ), is the type scheme ∀tn.τ , where tn = ftv(τ) \ ftv(E).When B is a basis whose range contains only type sequences (rather thanarbitrary type schemes), closE(B), the closure of B with respect to E, is thebasis {X : closE(τ) | X : τ ∈ B}.2.7 Environment modification and projectionWhen E is an environment, Γ a typing and B a basis, E+B means E+({}, B),and E + Γ means E + (Γ, {}).Given an environment E, the expression C of E accesses the C componentof E, namely, Γ of E means “the typing component of E” and B of E means“the basis component of E”.52.8 Derived forms for typesNotation αn → βm, for n,m ≥ 0, is used to emphasize the “functional” natureof some methods, and abbreviates type {val : αn{val : βm}}. For empty typesequences (when n or m are 0) we write () instead of ε.2.9 Types for primitive operations and objectsCore-TyCO has as predefined the primitive types int, bool, and string, alongwith the following operations.+ : int int → int- : int int → int* : int int → int/ : int int → int% : int int → int- : int → int^ : string string → stringand : bool bool → boolor : bool bool → boolnot : bool → boolThe usual relational operations are also provided. Currently they may takeas arguments only integers.= : int int → bool<> : int int → bool< : int int → bool<= : int int → bool> : int int → bool>= : int int → boolA basic stream based I/O facility is available by means of an object io.io : {getb : () → bool,putb : bool,geti : () → int,puti : int,gets : () → string,puts : string}2.10 Inference rulesVariables Γ ` var ⇒ typex ∈ dom(Γ)Γ ` x⇒ Γ(x)(1)x 6∈ dom(Γ)Γ ` x⇒ α(2)6Comment:(2) Allows for free variables in processes.Sequences of variables Γ ` varseq ⇒ typeseqΓ ` x⇒ α 〈Γ + {x : α} ` varseq ⇒ αn〉Γ ` x 〈, varseq〉 ⇒ α〈αn〉(3)Comment:When the option is present, varseq is a sequence of n variables.Expressions Γ ` exp ⇒ type,ΓFunction typeof, when applied to a constant or a primitive operator, returns itstype.Γ ` c⇒ typeof(c), {} (4)Γ ` x⇒ αΓ ` x⇒ α, {x : α}(5)typeof(binop) = ρ1 ρ2 → ρΓ ` exp1 ⇒ ρ1,Γ1 Γ ` exp2 ⇒ ρ2,Γ2 Γ1  Γ2Γ ` exp1 binop exp2 ⇒ ρ,Γ1 + Γ2(6)typeof(unop) = ρ→ ρ′ Γ ` exp ⇒ ρ,Γ′Γ ` unop exp ⇒ ρ′,Γ′(7)Comments:(6) By the current definition of binary operators, both parameters alwayshave the same type, so ρ1 = ρ2.(7) Both the parameter and the returned result of all current unary operatorshave the same type, so ρ = ρ′.Sequences of expressions Γ ` expseq ⇒ typeseq,ΓΓ ` exp ⇒ α,Γ′ 〈Γ + Γ′ ` expseq ⇒ αn,Γ′′〉Γ ` exp 〈, expseq〉 ⇒ α〈αn〉,Γ′〈+ Γ′′〉(8)Comment:When the option is present, expseq is a sequence of n expressions.Methods E ` method ⇒ %,ΓE 〈+ {xn : αn}〉 ` proc ⇒ ΓE ` l(〈x1, . . .,xn〉) = proc ⇒ {l : ε〈αn〉},Γ〈\ {xn}〉(9)7Comment:When the option is present, the variables xn don’t appear in the resultingtyping.Method rows E ` methrow ⇒ %,ΓE ` method ⇒ %,Γ E ` methrow ⇒ %′,Γ′ Γ  Γ′E ` method 〈, methrow〉 ⇒ %〈+ %′〉,Γ〈+ Γ′〉(10)Comment:When the option is present, we have dom(%)∩dom(%′) = ∅, by the syntacticrestrictions.Processes E ` proc ⇒ ΓE ` inaction⇒ {} (11)Γ of E ` a⇒ % 〈Γ of E ` expseq ⇒ αn,Γ〉 l ∈ dom(%) ∧ %  {l : ε〈αn〉}E ` a!l[〈expseq〉]⇒ {a : %} 〈+ Γ〉(12)Γ of E ` a⇒ {}〈+ %〉 〈E ` methrow ⇒ %,Γ {a : %}  Γ〉E ` a?{〈methrow〉}⇒ {a : {}〈+ %〉} 〈+ Γ〉(13)E ` proc1 ⇒ Γ1 E ` proc2 ⇒ Γ2 Γ1  Γ2E ` proc1 | proc2 ⇒ Γ1 + Γ2(14)E + {x : α} ` proc ⇒ ΓE ` new x proc ⇒ Γ \ {x}(15)B of E(X)  ε〈αn〉 〈Γ of E ` expseq ⇒ αn,Γ〉E ` X[〈expseq〉]⇒ {}〈+ Γ〉(16)E ` dec ⇒ B E +B ` proc ⇒ ΓE ` def dec in proc ⇒ Γ(17)E ` proc ⇒ ΓE ` (proc)⇒ Γ(18)Γ of E ` exp ⇒ bool,ΓE ` proc1 ⇒ Γ1 E ` proc2 ⇒ Γ2 Γ  Γ1  Γ2E ` if exp then proc1 else proc2 ⇒ Γ + Γ1 + Γ2(19)8Comments:(12) Object a must contain (at least) a method l, accepting as arguments nvalues of types αn, for n ≥ 0.(15) Bound variable x does not appear in the resulting typing.(16) When the option is present, the instantiation of type schemes allowsdifferent occurrences of a process variable to have different types.Bindings E ` bind ⇒ BE 〈+ {xn : αn}〉 ` proc ⇒ {}〈+ {xn : αn}〉E ` X(〈x1, . . . ,xn〉) = proc ⇒ {X : ε〈αn〉}(20)Comment:In the resulting basis, process variable X always has a type instead of a typescheme.Multiple bindings E ` multbind ⇒ BB = B′ +B′′E +B ` bind ⇒ B′ E + B ` multbind ⇒ B′′E ` bind 〈and multbind〉 ⇒ B(21)Comment:When the option is present, the syntactic restrictions assure that dom(B′)∩dom(B′′) = ∅.Declarations E ` dec ⇒ BE ` multbind ⇒ BE ` dec ⇒ closE(B)(22)Comment:By rules (20) and (21) we have that basis B contains only types. The closureof B is what allows process variables to be used polymorphically, via rule (16) (inrule (17), proc is typed in an environment that already includes the polymorphicbasis).Programs E ` program ⇒ ΓE ` program ⇒ {} (23)Comment:A program must have no free variables.3 Dynamic semantics3.1 Free identifiersA variable x occurs free in a process P if x is not in the scope P of a methodl( . . . x . . . ) = P , a process binding X( . . . x . . .) = P , or a scope restriction9new x P ; otherwise it occurs bound. The set of free variables in a process P isdenoted by fn(P ).A process variableX occurs free in a process ifX is not in the scope P,Q〈, D〉of a declaration def X( . . . ) = Q 〈and D〉 in P ; otherwise it occurs bound. Theset of free process variables in a process P is denoted by fv(P ).3.2 Variable substitution and α-conversionThe simultaneous substitution of free variables xn in a process P by values vn,for n ≥ 0, and provided that each x does not appear twice in xn, is denoted byP [vn/xn].A process P is α-convertible to Q if Q results from P by a series of changesof bound variables and bound process variables.3.3 Structural congruenceProcesses proc ≡ procP is α-convertible to QP ≡ Q(1)P | Q ≡ Q | P (2)(P | Q) | R ≡ P | (Q | R) (3)P | inaction ≡ P (4)new x inaction ≡ inaction (5)new x new y P ≡ new y new x P (6)x 6∈ fn(Q)(new x P) | Q ≡ new x P | Q(7)def D in inaction ≡ inaction (8)x 6∈ fn(D)def D in new x P ≡ new x def D in P(9)fv(D) ∩ fv(Q) = ∅(def D in P) | Q ≡ def D in (P | Q)(10)10Method rows methrow ≡ methrowM ′+ is a permutation of M+M ′+ ≡M+(11)Declarations dec ≡ decD′ is a permutation of DD′ ≡ D(12)3.4 Reduction rulesExpressions exp → valval → val (1)exp1 → c1 exp2 → c2exp1 binop exp2 → c1 binop c2(2)exp → cunop exp → unop c(3)Comment:(1) Constants and variables reduce to themselves.Sequences of expressions expseq → valseqexp → v 〈expseq → vn〉exp 〈, expseq〉 → v〈vn〉(4)Processes proc → proc〈expseq → vn〉a!l[〈expseq〉] | a?{l(〈x1, . . . ,xn〉) = P 〈, methrow〉}→ P 〈[vn/xn]〉(5)〈expseq → vn〉def X(〈x1, . . . ,xn〉) = P 〈and D〉 in X[〈expseq〉] 〈| Q〉 →def X(〈x1, . . .,xn〉) = P 〈and D〉 in P 〈[vn/xn]〉 〈| Q〉(6)P → P ′P | Q→ P ′ | Q(7)11P → P ′new x P → new x P ′(8)P → P ′def D in P → def D in P ′(9)P ≡ P ′ P ′ → Q′ Q′ ≡ QP → Q(10)References[1] Robin Milner. Functions as processes. Journal of Mathematical Structuresin Computer Science, 2(2):119–141, 1992.[2] Robin Milner, Mads Tofte, Robert Harper, and David MacQueen. TheDefinition of Standard ML (Revised). MIT Press, 1997.[3] Vasco T. Vasconcelos. TyCO: the language definition, version 0.0. KeioUniversity, July 1993.[4] Vasco T. Vasconcelos. Predicative polymorphism in π-calculus. In 6th Paral-lel Architectures and Languages Europe, volume 817 of LNCS, pages 425–437.Springer-Verlag, July 1994.[5] Vasco T. Vasconcelos and Mario Tokoro. A typing system for a calculusof objects. In 1st ISOTAS, volume 742 of LNCS, pages 460–474. Springer-Verlag, November 1993.12new x1, . . .,xn proc =⇒ new x1 · · · new xn proca?(〈varseq〉) = proc =⇒ a?{val(〈varseq〉) = proc}a![〈expseq〉] =⇒ a!val[〈expseq〉]l( . . . _ . . .) = proc =⇒ l( . . . z . . . ) = procX( . . . _ . . . ) = proc =⇒ X( . . . z . . . ) = procif exp then proc =⇒ if exp then proc else inactionbranch a!〈l〉[〈expseq〉] =⇒ new zinto {〈methrow〉} a!〈l〉[〈expseq, 〉z] | z?{〈methrow〉}branch X[〈expseq〉] =⇒ new zinto {〈methrow〉} X[〈expseq, 〉z] | z?{〈methrow〉}let varseq = a!〈l〉[〈expseq〉] =⇒ branch a!〈l〉[〈expseq〉]in proc into {val(varseq) = proc}let varseq = X[〈expseq〉] =⇒ branch X[〈expseq〉]in proc into {val(varseq) = proc}Figure 5: Derived Formsu, t or typevar ∈ TypeVartypevarseq ∈ TypeVarSeq = TypeVarnρ or primtype ∈ PrimType = {int, bool, string}Figure 6: Simple Semantic Objectsα, β ∈ Type = PrimType ∪ TypeVar ∪RcdType ∪ RecTypeτ or αn ∈ TypeSeq = Typenε ∈ Type0% ∈ RcdType = Label 7→ TypeSeqµt.α ∈ RecType = TypeVar× Typeσ or ∀tn.τ ∈ TypeScheme =⋃n≥0 TypeVarn × TypeSeqΓ,∆ ∈ Typing = Var 7→ TypeB ∈ Basis = ProcVar 7→ TypeSchemeE ∈ Env = Typing× BasisFigure 7: Compound Semantic Objects13

https://repositorio.ul.pt/bitstream/10451/14116/1/98-3.pdf

Core-TyCO, The Language Definition, Version 0.1

Abstract

Similar works

Full text

Available Versions

Repositório da Universidade de Lisboa

Universidade de Lisboa: Repositório.UL