A¸c˜ao Parametrizada - Regras de Tipos - Definição e implementação do sistema de tipos da lingu

3.2 Regras de Tipos

3.2.11 A¸c˜ao Parametrizada

Uma a¸cão parametrizada está bem tipada se a declara¸cão dos parâmetros (Declaration) estiver bem tipada; e se a a¸cão envolvida (Action) também estiver bem tipada, em um contexto que inclui os parâmetros declarados.

Γ B d : Declaration (Γ ⊕ (params = Decs d)) B a : Action Γ B d • a : Action Parametrised(d)

Assim como ocorre com processos parametrizados, uma a¸cão parametrizada está bem tipada se o corpo da a¸cão está bem tipado quando o ambiente é enriquecido com as defini¸cões dos parâmetros. No entanto, apenas o contexto da a¸cão pode fazer referências a esses parâmetros. No exemplo a seguir, mostramos um caso de inconsistência na referência aos parâmetros de uma a¸cão.

channel out : N process P b= begin ... A b= x , y : N • B; Skip B b= out!x + y → Skip • Skip end

No exemplo, definimos uma a¸cão parametrizada A, cujos os parâmetros são x : N e y : N. Esta a¸cão referencia uma outra a¸cão B. O problema está na a¸cão B, já que ela está fazendo referências aos parâmetros x e y da a¸cão A. Isto é um erro pois o contexto destes parâmetros é apenas a a¸cão B; Skip. Refor¸cando o que já foi dito na Se¸cão 3.1: cada a¸cão tem seu próprio contexto, e o que for definido em uma a¸cão não está no escopo de nenhuma outra a¸cão.

3.2.12 A¸c˜ao

Action ::= Schema-Exp

Uma expressão de esquema bem tipada é uma a¸cão bem tipada. Γ B sc : Schema-Exp

Γ B sc : Action

Action ::= N

Uma referência a uma a¸cão está bem tipada se o nome N tiver sido declarado antes como uma a¸cão e não for um nome de a¸cão parametrizada.

n ∈ (Γ.actions) n 6∈ (Γ.parActions) Γ B n : Action

Considerando o mesmo exemplo da regra de a¸cão parametrizada, caso a a¸cão principal fosse uma chamada à a¸cão A, sem a passagem de argumentos, ter´ıamos erro de tipos pois A é uma a¸cão parametrizada, e exige argumento na sua instancia¸cão.

Action ::= ParCommand

Um comando parametrizado é uma a¸cão. Ele está bem tipado, como uma a¸cão, se for um comando bem tipado.

Γ B c : ParCommand Γ B c : Action

Action ::= Action[N+_{:= N}+_]

A substitui¸cão de a¸cão se assemelha bastante com a renomea¸cão de processo. A diferen¸ca é que, além de estarmos tratando com a¸cões, os nomes envolvidos na substitui¸cão devem ser nomes de variáveis locais já declaradas no processo que contém a a¸cão.

De forma semelhante, uma substitui¸cão de a¸cão está bem tipada se a a¸cão envolvida (Action) estiver bem tipada; os nomes das listas da substitui¸cão tiverem sido declarados antes e apresentarem a mesma quantidade de elementos; e os nomes do lado direito da substitui¸cão tiverem o mesmo tipo da variável correspondente do lado esquerdo.

Γ B a : Action ]ln1 == ]ln2 (Into ln1 dom(Γ.localVars))

(Into ln2 dom(Γ.localVars)) (CheckVarsRenaming ln1 ln2 Γ)

A condi¸cão CheckVarsRenaming requer que cada nome contido na segunda lista da subs- titui¸cão (ln2) possua o mesmo tipo da variável correspondente da primeira lista (ln1).

Action ::= Skip | Stop | Chaos

A¸cões básicas estão sempre bem tipadas.

Γ B Skip : Action Γ B Stop : Action Γ B Chaos : Action

Action ::= Communication → Action

Um prefixing está bem tipado se a comunica¸cão estiver bem tipada e a a¸cão envolvida também estiver bem tipada, em um ambiente estendido pelas variáveis de entrada da comunica¸cão. Os tipos das variáveis de entrada são determinados pelo tipo do canal usado para comunica¸cão.

Γ B c : Communication (Γ ⊕ VarsC c Γ) B a : Action Γ B c → a : Action

A fun¸cão VarsC , aplicada à comunica¸cão e ao ambiente de tipos corrente, retorna um outro ambiente contendo todas as variáveis de entrada de uma comunica¸cão associadas aos tipos extra´ıdos a partir do tipo do canal. O ambiente retornado também contém as varia¸cões das variáveis de entrada extra´ıdas. Por exemplo, se foi identificada a variável de entrada x : T , o ambiente também conterá x0 _{: T , x ? : T e x ! : T . Os valores}

do ambiente retornado pela fun¸cão atualizam o ambiente de tipos corrente através da aplica¸cão da fun¸cão overriding (⊕). Para exemplificar a extra¸cão das variáveis de entrada, consideremos o programa a seguir.

[T ] channel c : N × T × N process P b= begin A b= c?a?b!a → Skip B b= c?x ?y → Stop C b= c?z → Skip • A; B; C end

As variáveis de entrada extra´ıdas da comunica¸cão da a¸cão A serão: a : N, a0 _{: N, a? : N,}

a! : N, b : T , b0 _{: T , b? : T e b! : T . A vari´avel a, por ser o primeiro parˆametro da comu-}

nica¸cão, assumirá o tipo do primeiro elemento que compõe o tipo do canal, no caso, N. O mesmo racioc´ınio serve para o parâmetro de comunica¸cão b, mas neste caso, ele assumirá o tipo do segundo elemento que compõe o tipo do canal. No caso da comunica¸cão da a¸cão B, as variáveis de entrada extra´ıdas serão: x : N (e suas varia¸cões) e y : T × N (e suas varia¸cões). Como temos apenas dois parâmetros de comunica¸cão, o tipo do último parâmetro é a tupla T × N. Finalmente, no caso da comunica¸cão da a¸cão C , como o canal c está comunicando um único parâmetro, e este é de entrada, ele assume o tipo completo do canal. Portanto, as variáveis de entrada extra´ıdas são: z : N × T × N, z0 _{: N × T × N, z ? : N × T × N e z ! : N × T × N.}

Action ::= Predicate & Action

Uma a¸cão guardada está bem tipada se a guarda (Predicate) e a a¸cão envolvida (Action) estiverem bem tipadas.

Γ B p : Predicate Γ B a : Action Γ B p & a : Action

Action ::= Action ; Action | Action ||| Action | Action u Action | Action 2 Action

A verifica¸cão de uma combina¸cão de a¸cões é semelhante à verifica¸cão de uma combina¸cão de processos: verificamos se as a¸cões envolvidas estão bem tipadas.

Γ B a1 : Action Γ B a2 : Action

Γ B a1 2 a2 : Action

Refor¸cando a idéia de contexto: as variáveis definidas na a¸cão (a1) não atualizam o

ambiente da a¸c˜ao (a2). Desta forma, no exemplo de a¸c˜ao abaixo, teremos um erro.

A b= (c?x → c?y → c!x + y → Skip) 2

(c!x + x → Stop)

Seja c um canal definido com o tipo N, a primeira a¸cão da escolha externa do exemplo acima define as variáveis locais x e y do tipo N (e suas varia¸cões). No entanto, a a¸cão posterior da escolha externa faz referência à variável x . Se x não foi definida globalmente ou dentro do processo como sendo do tipo N, teremos erro na a¸cão do exemplo pois, c!x + x → Skip faz referência a um nome que não está no seu escopo.

Action ::= Action |[ NSExpresion | CSExpression | NSExpression ]| Action

A verifica¸cão de tipos de um paralelismo de a¸cões se assemelha à verifica¸cão anterior. Adicionalmente, temos que verificar se a expressão do conjunto de canais (CSExpression) também está bem tipada.

Γ B a1 : Action Γ B a2 : Action Γ B ns1 : NSExpression

Γ B ns2 : NSExpression Γ B cs : CSExpression

Γ B a1|[ ns1| cs | ns2]| a2 : Action

Action ::= N(Expression+₎

A verifica¸cão de uma instancia¸cão de a¸cão parametrizada se assemelha à verifica¸cão de uma instancia¸cão de processo parametrizado, sendo que ao invés de lidar com processos, aqui tratamos com a¸cões.

n ∈ dom(Γ.parActions) Γ B le : ExpressionList(T ) (Check (Γ.parActions n) T )

Γ B n(le) : Action

Action ::= µ N • Action

Uma a¸cão recursiva está bem tipada se a a¸cão envolvida (Action) estiver bem tipada, podendo usar o nome N como um nome de a¸cão.

(Γ ⊕ (definedActs = {n})) B a : Action Γ B µ n • a : Action

Mesmo o nome N sendo inclu´ıdo no ambiente como uma a¸cão, vale ressaltar que o con- texto deste novo nome de a¸cão será apenas a a¸cão a indicada na regra acima. Consider- emos o exemplo a seguir para explicar melhor esta observa¸cão.

A b= (µ X • B; X ) B b= (µ Y • A); Y

No exemplo, definimos duas a¸cões recursivas. Na a¸cão A, o contexto do nome X é a composi¸cão sequencial de a¸cões: B; X . Desta forma, está correta a referência de X como a¸cão neste caso. Já na a¸cão B, o contexto do nome Y é apenas a referência à a¸cão A. Portanto, esta a¸cão apresenta um erro, pois Y está sendo usado como nome de a¸cão fora do contexto da recursão.

Action ::= o

9Declaration • Action | ||| Declaration • Action

A verifica¸cão de tipos de uma parametriza¸cão iterativa de a¸cões é semelhante à verifica¸cão de parametriza¸cão iterativa de processos, sendo que aqui estamos tratando com a¸cões. Da mesma forma, aqui os parâmetros declarados entram no contexto da a¸cão.

Γ B d : Declaration (FiniteDecs d ) (Γ ⊕ (params = Decs d )) B a : Action

Γ B o

9 d • a : Action

Action ::= ||| Declaration • k[NSExpression]kAction

A regra de interleaving iterativo de a¸cões é semelhante às regras de parametriza¸cão ite- rativa de a¸cões, descritas anteriormente, acrescentando-se a condi¸cão de que a expressão de conjunto de nomes (NSExpression) também deve estar bem tipada.

Γ B d : Declaration (Γ ⊕ (params = Decs d)) B a : Action (FiniteDecs d) Γ B ns : NSExpression

Γ B ||| d • k[ns]ka : Action

3.2.13 Comunica¸c˜ao Communication ::= N

Uma sincroniza¸cão está bem tipada se o nome N tiver sido declarado antes como um canal de sincroniza¸cão.

n ∈ dom(Γ.channels) Γ.channels n == wt Γ B n : Communication

O que determina se um canal é de sincroniza¸cão é a ausência de tipo associado ao canal. Como vimos na Se¸cão 3.1, a ausência de tipos de um canal é representado pelo s´ımbolo wt. A condi¸cão n ∈ dom(Γ.channels) da regra acima é verdadeira apenas se o nome do canal estiver contido no ambiente, o que significa que ele foi declarado. Já a condi¸cão Γ.channels n == wt é verdadeira se, e somente se, o canal for de sincroniza¸cão.

Communication ::= N CParameter+

Uma comunica¸cão que envolve passagem de valores está bem tipada se o nome N tiver sido declarado antes como um canal com tipo; e se cada um dos parâmetros de comunica¸cão (CParameter) envolvidos estiverem bem tipados. O número de elementos da lista de parâmetros deve ser menor ou igual ao número de elementos que compõem o tipo do canal envolvido na comunica¸cão. Consideramos que um tipo é composto de mais de um

elemento quando assume a forma de um produto cartesiano. n ∈ dom(Γ.channels)

((Γ.channels n) 6= wt) ]cpl ≤ (NumTypesChan (Γ.channels n)) (NoConflicts (Extract cpl T )) Γ B cpl : CParameterList(T )

Γ B n cpl : Communication where T = Γ.channels n

A fun¸cão NumTypesChan recebe como argumento o tipo do canal envolvido na comu- nica¸cão, e retorna a quantidade de componentes dele. Já a fun¸cão Extract recebe como argumentos a lista de parâmetros da comunica¸cão e o tipo do canal. Ela retorna um conjunto contendo todas as variáveis de entrada da comunica¸cão e suas varia¸cões. Este conjunto, por sua vez, é passado como argumento para a fun¸cão NoConflicts e ela resulta em verdadeiro se, e somente se, não existirem redeclara¸cões de nomes com tipos diferentes.

Communication ::= N [Expression+_{] CParameter}+

Uma comunica¸cão através de uma instancia¸cão de um canal genérico está bem tipada se: o nome N tiver sido declarado antes como um canal genérico;

as express˜oes envolvidas (Expression+_{) estiverem bem tipadas, e forem do tipo con-}

junto;

o número de expressões for igual ao número de parâmetros genéricos do canal; cada um dos parâmetros de comunica¸cão (CParameter) envolvidos estiverem bem

tipados, em um contexto onde o tipo do canal genérico usado na comunica¸cão for instanciado pelos tipos passados através da lista de expressões;

e o número de elementos da lista de parâmetros for menor ou igual ao número de elementos que compõem o tipo do canal.

n ∈ dom(Γ.genericChannels) Γ B le : ExpressionList(P T0₎

]le == ](Γ.genericChannels n) ]cpl ≤ (NumTypesChan (Γ.channels n)) (NoConflicts (Extract cpl T )) Γ0 _{B cpl : CParameterList(T )}

Γ B n[le]cpl : Communication

where Γ0 _{= Γ ⊕ (InstantiateTypesGenChan (Γ.genericsChannels n) le n T ),}

T = Γ.channels n

a regra de comunica¸cão, com condi¸cões adicionais: a lista de expressões precisa estar bem tipada e a condi¸cão ]le == ](Γ.genericChannels n) requer que o número de elementos da lista de expressões seja igual ao número de parâmetros genéricos do canal. O detalhe desta regra é que o ambiente de tipos para a verifica¸cão dos parâmetros da comunica¸cão (Γ0_{) é atualizado com o canal instanciado. A fun¸cão InstantiateTypesGenChan recebe}

como argumentos o conjunto com os parâmetros genéricos do canal, a lista de expressões que irão instanciar os tipos genéricos do canal, o nome do canal e seu tipo. Ela retorna um ambiente com o canal em questão instanciado. Vejamos como isso ocorre no exemplo a seguir.

channel c1 : N

channel [X ]c2 : X

process P b= begin • c1?v → c2[N]!v → Skip end

No exemplo acima, temos a defini¸c˜ao de um canal gen´erico c2 de tipo X . O processo P

possui na sua a¸cão principal uma instancia¸cão a este canal genérico: o parâmetro genérico X está sendo instanciado com o tipo N. Pela regra de tipos, o ambiente do parâmetro de comunica¸cão !v contém o canal c2 instanciado com o tipo N. Como v é do tipo N

(extra¸cão da variável a partir da comunica¸cão c1?v ), a instancia¸cão da comunica¸cão está,

portanto, bem tipada.

3.2.14 Parˆametros de Comunica¸c˜ao

Uma lista de parâmetros de comunica¸cão está bem tipada se cada parâmetro de comunica¸cão envolvido estiver bem tipado. O ambiente de tipos de um parâmetro de comunica¸cão é atualizado pelas variáveis de entrada (e suas varia¸cões) dos parâmetros de comunica¸cão imediatamente anteriores a ele.

Γ B cp : CParameter(GetTypeHead T )

(Γ ⊕ (ExtractVarsCP cp T )) B cpl : CParameterList(GetTypeTail T ) Γ B cp cpl : CParameterList(T )

As fun¸cões GetTypeHead e GetTypeTail recebem como argumento o tipo do canal. A primeira fun¸cão retorna o primeiro elemento que compõe o tipo do canal, e a segunda fun¸cão retorna um tipo sem o primeiro elemento que compõe o tipo do canal. Por exemplo, se o tipo do canal for N × T × U , a fun¸cão GetTypeHead retorna o tipo N, e a fun¸cão GetTypeTail retorna o tipo T × U .

A fun¸cão ExtractVarsCP recebe como argumentos um parâmetro de comunica¸cão e o tipo deste parâmetro, e retorna um ambiente contendo todas as variáveis de entrada com suas varia¸cões. Este ambiente atualiza o ambiente Γ, através da fun¸cão overriding, e isto permite que os demais parâmetros de comunica¸cão sejam verificados com as informa¸cões

destas vari´aveis extra´ıdas, conforme apresentamos no exemplo a seguir. channel c : N × N × N process P b= begin ... A b= c?x ?y!x + y → Stop • A end

Na a¸cão A deste exemplo, a expressão do terceiro parâmetro da comunica¸cão (x + y) utiliza as variáveis de entrada dos parâmetros anteriores. Isto só é poss´ıvel devido à extensão do contexto das variáveis de entrada dos parâmetros de comunica¸cão.

Uma lista de parâmetros de comunica¸cão pode ser composta por apenas um parâmetro. Neste caso, a lista está bem tipada se este parâmetro estiver bem tipado.

Γ B cp : CParameter(T ) Γ B cp : CParameterList(T )

CParameter ::= ?N

Um parâmetro de entrada está bem tipado. N é uma variável nova, e seu tipo é definido a partir do tipo do canal, conforme vimos nas regras anteriores.

Γ B ?cp : CParameter(T )

CParameter ::= ?N : Predicate

Um parâmetro de entrada com restri¸cão está bem tipado se o predicado que define a restri¸cão estiver bem tipado, podendo usar as variáveis de entrada extra´ıdas do parâmetro de comunica¸cão. N é uma variável nova, cujo tipo é igual ao tipo do canal ou ao tipo do componente correspondente a N no produto cartesiano que define o tipo do canal.

(Γ ⊕ (ExtractCP cp T )) B p : Predicate Γ B (?cp : p) : CParameter(T )

Um parâmetro de sa´ıda está bem tipado se a expressão (Expression) envolvida estiver bem tipada, e for do tipo do canal ou do componente correspondente à expressão no produto cartesiano que define o tipo do canal.

Γ B e : Expression(T0₎ _T0 _{== T}

Γ B !e : CParameter(T )

3.2.15 Comando Parametrizado ParCommand ::= Command

Um comando simples ´e um comando parametrizado, e ele est´a bem tipado, como um comando parametrizado, se for um comando bem tipado.

Γ B c : Command Γ B c : ParCommand

ParCommand ::= (QualifiedDecl • Command)

Neste caso, o comando parametrizado está bem tipado se a declara¸cão de parâmetros (QualifiedDecl) estiver bem tipada e se o comando envolvido (Command) também estiver bem tipado, em um contexto que inclui os parâmetros declarados.

Γ B pd : QualifiedDeclaration (Γ ⊕ (VarsParDec pd)) B c : Command Γ B pd • c : ParCommand(pd)

Esta regra se assemelha às demais regras de processos e a¸cões parametrizadas. Da mesma forma, os parâmetros entram no contexto da verifica¸cão do comando. Isso significa que os nomes dos parâmetros podem ser usados livremente dentro do comando, desde que sejam obedecidas as regras de tipo. No entanto, no caso de um comando parametrizado, os parâmetros podem ser usados como variáveis, diferentemente dos parâmetros de processos e a¸cões.

A fun¸cão VarsParDec, aplicada à lista de parâmetros, retorna um novo ambiente con- tendo todos os parâmetros (e suas varia¸cões) associados aos seus tipos correspondentes. As defini¸cões deste ambiente atualizam o ambiente de tipos corrente e permite a verifica¸cão de tipos do comando com os parâmetros em escopo.

3.2.16 Declara¸c˜ao de Parˆametros QualifiedDecl ::= val Declaration

| res Declaration | valres Declaration

Uma declara¸cão de parâmetros está bem tipada se a parte declarativa (Declaration) estiver bem tipada.

Γ B d : Declaration

Γ B val d : QualifiedDeclaration

QualifiedDecl ::= QualifiedDecl; QualifiedDecl

Uma composi¸cão de declara¸cão de parâmetros está bem tipada se cada uma das declara¸cões envolvidas (QualifiedDecl) estiverem bem tipadas. O ambiente de cada declara¸cão de parâmetro é atualizado pelos parâmetros das declara¸cões anteriores.

Γ B pd1 : QualifiedDeclaration Γ0 B pd2 : QualifiedDeclaration

Γ B pd1; pd2 : QualifiedDeclaration

where Γ0 _{= Γ ⊕ (VarsParDec pd}

3.2.17 Comando

Para exemplificar cada regra de comando descrita nesta se¸c˜ao, vamos considerar o programa abaixo. x : N channel c : N process P b= begin state St b= [s : N | s ≥ 0] A b= z : N • c?y → y : [z > 2, y0 _{= x ];} (var t : N • t := x ); t := z ;

(val a : N; res b : N • b := a)(3, s) if z = 0 → Skip

[] z > 0 → Stop fi

• A(10) end

Neste programa, o processo P define uma a¸cão parametrizada A, cujo corpo é formado pela composi¸cão seqüencial de alguns comandos. Nas regras a seguir, faremos referências

a este programa para mostrar os pontos onde a verifica¸cão de tipos dos comandos ocor- rerá com sucesso ou não.

Command ::= N+_{: [Predicate, Predicate]}

Um comando de especifica¸cão está bem tipado se os predicados (Predicate) envolvidos estiverem bem tipados, e se as variáveis do quadro (N+_{) forem distintas entre si e estiverem}

em escopo.

(NoRep ln) (Into ln dom(Γ.localVars)) Γ B pre : Predicate Γ B post : Predicate

Γ B ln : [pre, post] : Command

Observando o exemplo do in´ıcio desta se¸cão, o comando de especifica¸cão da a¸cão A está bem tipado, pois y é uma variável que está em escopo, e os predicados estão bem tipados, de acordo com as regras de tipo de Z (lembrando que a variável y0 _{é introduzida no ambi-}

ente atrav´es da comunica¸c˜ao c?y). Entretanto, se o comando fosse y, t, y : [z > 2, y0 _{= x ],}

ele não estaria bem tipado pois além de haver repeti¸cões de nomes no quadro, o nome t não está no escopo do comando. E se o comando fosse z : [y > 0, z0 _{= y], também não}

estaria bem tipado já que z é um parâmetro da a¸cão e não pode ser tratado como uma variável: ele não pode estar no quadro de uma especifica¸cão e nem ser atribu´ıdo.

Command ::= N+_{:= Expression}+

Um comando de atribui¸cão está bem tipado se as expressões envolvidas (Expression+_{) es-}

tiverem bem tipadas, e se resultarem em valores dos tipos das variáveis do lado esquerdo (N+_{). Além disto, estas variáveis já devem ter sido declaradas. O número de expressões}

deve ser igual ao número de variáveis do lado esquerdo da atribui¸cão. NoRep ln (Into ln dom(Γ.localVars))

]ln == ]le (Verify ln le Γ) Γ B ln := le : Command

A fun¸cão Verify, aplicada à lista de nomes, à lista de expressões, e ao ambiente de tipos atual, resulta em verdadeiro se, e somente se, houver consistência de tipos entre as variáveis do lado esquerdo do comando de atribui¸cão e os respectivos tipos das expressões do lado direito do comando.

No exemplo, os comandos de atribui¸cão t := x e b := a estão bem tipados pois os nomes estão em escopo e possuem os mesmos tipos. Além disto, os nomes do lado es- querdo das atribui¸cões são nomes de variáveis. Já a atribui¸cão t := z não está bem tipada pois a variável t não está no escopo da atribui¸cão.

Um comando de declara¸cão de variáveis está bem tipado se a parte declarativa (Declaration) estiver bem tipada, e se a a¸cão envolvida também estiver bem tipada, no contexto das variáveis declaradas.

Γ B d : Declaration (Γ ⊕ (VarsDec d)) B a : Action Γ B var d • a : Command

A fun¸cão VarsDec, aplicada à declara¸cão, retorna um ambiente de tipos contendo todas as variáveis declaradas e seus respectivos tipos, como também, todas as varia¸cões destas variáveis. Por exemplo, se for declarada uma variável x do tipo T , a fun¸cão não apenas irá retornar um ambiente contendo esta variável, como também as variáveis x0_{, x ?, x !}

com o mesmo tipo T .

No exemplo do in´ıcio desta se¸cão, a declara¸cão da variável t : N estende o escopo do comando de atribui¸cão t := x . Por isto, ele está bem tipado. No entanto, o escopo desta variável declarada não inclui a atribui¸cão seguinte (t := z ).

Command ::= [Predicate] | {Predicate}

Uma suposi¸cão, ou coer¸cão, está bem tipada se o predicado envolvido (Predicate) estiver bem tipado.

Γ B p : Predicate Γ B [p] : Command

Γ B p : Predicate Γ B {p} : Command

Command ::= (QualifiedDecl • Command)(Expression+₎

A verifica¸cão de uma instancia¸cão de comando parametrizado é semelhante à verifica¸cão de tipos de instancia¸cões de processos e a¸cões parametrizadas. Sendo que aqui, estaremos tratando com comandos.

Γ B d • c : ParCommand(d)

Γ B le : ExpressionList(T ) Check ((DecsParDec d ) T ) (VerifyParDec (ExtractParDecs d ) le Γ)

Γ B (d • c)(le) : Command

A fun¸cão DecsParDec recebe como argumento uma declara¸cão de parâmetros, e retorna um conjunto contendo todas os nomes dos parâmetros mapeados a seus respectivos tipos. Já a fun¸cão VerifyParDec, aplicada a uma declara¸cão de parâmetros, a uma lista de expressões e ao ambiente de tipos corrente, resulta em verdadeiro se, e somente se, os

No documento Definição e implementação do sistema de tipos da linguagem circus (páginas 79-93)