Intuição da sintaxe de L2 (35)

Transcrição

1 2.2 A Linguagem L2 2.2 A Linguagem L2 A linguagem L2 é uma extensão de L1 com funções recursivas, memória (acesso e atualização de variáveis), sequência de comandos ( ; ) e laço de repetição while. Primeiro, devemos estender a sintaxe de L1: onde n Z b {true, false} op {, +} Sintaxe de L2 (34) e ::= n b e 1 op e 2 if e 1 then e 2 else e 3 ( ) l := e ( )! l ( ) skip ( ) e 1 ; e 2 ( ) while e 1 do e 2 fn x:t e e 1 e 2 x let x:t = e 1 in e 2 end ( ) let rec f:t 1 T 2 = (fn y:t 1 e 1 ) in e 2 end v ::= n b fn x:t e ( ) skip l Loc = {l 1, l 2, l 3,...} Intuição da sintaxe de L2 (35) Loc representa um conjunto de localizações de memória (ou endereços), cujos elementos vamos representar por l, l 1, l 2, l 3,.... Assumimos que Loc é contável e infinito (existem tantas posições de memória quanto necessitarmos). Vamos assumir que somente inteiros serão armazenados em memória. Isso permite considerar a memória uma função total σ : Loc int. 21

2 2 Semântica Operacional e Sistemas de Tipos l := e representa o armazenamento do resultado da avaliação de e no endereço l dentro da memória.! l representa acessar o valor armazenado em memória no endereço l, ao passo que que l representa o endereço em si. skip representa o comando que não faz nada. Ele é útil para simular a construção if-then a partir de if-then-else. c 1 ; c 2 executa inicialmente c 1 e somente após executa c 2. while e 1 do e 2 executa o teste e 1. Se este for falso, o comando termina. Se e 1 resultar em verdadeiro, o comando e 2 é executado e o processo é repetido. let rec f:t 1 T 2 = (fn y:t 1 e 1 ) in e 2 end permite o uso da função recursiva f dentro da expressão e 2. Linguagem de Tipos de L2 (36) os tipos da linguagem L2 são dados pela seguinte gramática: T ::= int bool unit T 1 T 2 unit representa o tipo de comandos, isto é, expressões cujo propósito não é retornar um valor, mas sim causar algum efeito colateral como modificar o estado das variáveis. Configurações (37) Nesta linguagem, ao contrário de L1, temos a ideia de que o programa roda ao lado de uma memória, que armazena o valor das variáveis. Portanto, ao dar semântica operacional, precisamos de duas informações: O estado atual do programa e P rog. O estado atual da memória σ Mem, onde Mem = (Loc int). Ao par e, σ damos o nome de configuração (ou estado da máquina abstrata). A semântica operacional será definida pela relação ( ) P rog, Mem P rog, Mem 22

3 2.2 A Linguagem L2 Nota: não estamos considerando entrada e saída de dados. Poderíamos assumir que o programa inicia com as entradas do problema preenchidas em certas posições de memória, e a saída pode ser obtida de outra posição de memória ou do resultado do programa em si. Nota: cada vez que estendemos a sintaxe da linguagem, precisamos atualizar as definições de fv (variáveis livres) e {e 1 /x}e 2 (substituição) para atuarem de forma consistente sobre as novas construções Funções recursivas Funções recursivas (38) A sintaxe e ::=... let rec f:t 1 T 2 = (fn y:t 1 e 1 ) in e 2 end permite descrever uma função f que, durante a sua execução, pode se chamar recursivamente. Note que a construção let comum não permitiria isso, pois o nome f estaria livre dentro do corpo da função. A regra de tipos precisa garantir que o corpo da função recursiva está bem tipado considerando a informação do parâmetro da função x e a possibilidade de chamada recursiva a f. Além disso, a expressão e 2 também precisa estar bem tipada, supondo que possamos realizar chamadas a f. Γ, f : T 1 T 2, y : T 1 e 1 : T 2 Γ, f : T 1 T 2 e 2 : T Γ let rec f:t 1 T 2 = (fn y:t 1 e 1 ) in e 2 end : T (Tletrec) A avaliação de expressões let rec, da mesma forma que o let, substitui todas as ocorrências de f dentro da expressão e 2. Contudo, ao invés de substituir f pela função (fn y:t 1 e 1 ), ele substitui por (fn y:t 1 let rec f:t 1 T 2 = (fn y:t 1 e 1 ) in e 1 end), que mantém o nome f preso em e 1 se alguma chamada recursiva a f precisar ser feita. A memória não é modificada por essa transformação. let rec f:t 1 T 2 = (fn y:t 1 e 1 ) in e 2 end, σ (letrec) {(fn y:t 1 let rec f:t 1 T 2 = (fn y:t 1 e 1 ) in e 1 end)/f}e 2, σ Segue abaixo a definição da função fatorial e a sua chamada para calcular o fatorial de 5 (neste exemplo supomos que operadores para igualdade, multiplicação e para subtração foram adicionados a linguagem): 23

4 2 Semântica Operacional e Sistemas de Tipos let rec f a t : int > int = (fn y : int => if y = 0 then 1 else y * f a t ( y 1 ) ) in f a t 5 end Comandos Skip e sequência (39) Γ skip : unit Γ e 1 : unit Γ e 2 : T Γ e 1 ;e 2 : T (Tskip) (Tseq) O sistema de tipos atribui a skip o tipo unit. Sequências de ações e 1 ;e 2 são bem tipadas somente quando e 1 é do tipo unit. Neste caso, o tipo da sequência é igual ao tipo de e 2. skip;e 2, σ e 2, σ (seq1) e 1, σ e 1, σ e 1 ;e 2, σ e 1 ;e 2, σ (seq2) Pela regra de reescrita seq2 acima, a avaliação sequencial de duas expressões é feita da esquerda para direita. Pela regra seq1 (uma regra de computação), quando o lado esquerdo estiver completamente reduzido para skip, a avaliação deve continuar com a expressão no lado direito do ponto e vírgula. Note que aqui foi feita uma escolha arbritrária no projeto da linguagem: a avaliação continua com a expressão no lado direito somente se a expressão do lado esquerdo do ponto e vírgula avalia para skip. Qualquer outra possibilidade leva a erro de execução. Operações com a Memória (40) Γ e : int Γ l:= e : unit Γ! l : int l Dom(σ) l:= n, σ skip, σ[l n] (Tatr) (Tderef) (atr1) 24

5 2.2 A Linguagem L2 e, σ e, σ l:= e, σ l:= e, σ (atr2) l Dom(σ) σ(l) = n! l, σ n, σ (deref) σ[l v] representa a memória com os mesmos valores armazenados que σ com exceção da posição l, a qual aponta para o valor v. Se l / Dom(σ), a memória σ[l v] é o resultado da definição de um novo mapeamento para uma nova posição l. Se l Dom(σ), a memória σ[l v] é o resultado da alteração do valor armazenado em l para v, destruindo o valor anteriormente armazenado em l. Observe que as operações de atribuição e derreferência (regras atr1 e deref) somente são executadas se o endereço l estiver mapeado na memória (formalizado pela premissa l Dom(σ)). Na regra atr1 podemos observar outras escolhas feitas em relação à semântica da linguagem: a memória somente pode receber valores inteiros e uma atribuição é reduzida para o valor skip. Em algumas linguagens de programação o valor final de uma expressão de atribuição é mesmo do valor atribuido. Note também que l 1, l 2, l 3,... (endereços) não são considerados objetos de primeira classe. Endereços não podem ser passados para ou retornados por funções. Os operadores de atribuição e dereferenciação necessitam referenciar endereços diretamente, não podendo ser aplicados sobre expressões que poderiam retornar endereços após algum cálculo. While (41) Γ e 1 : bool Γ e 2 : unit Γ while e 1 do e 2 : unit (Twhile) A regra de tipo de while e 1 do e 2 requer que e 1 seja uma expressão booleana, e que e 2 seja uma expressão do tipo unit (comando). while e 1 do e 2, σ if e 1 then (e 2 ;while e 1 do e 2 ) else skip, σ (while) O comando while e 1 do e 2 pode ser visto como uma sequência infinita de ifs encadeados. A regra de reescrita realiza a expansão em um passo do teste e execução como um if, retornando ao while e 1 do e 2 inicial após cada execução de e 2 (caso mais iterações sejam necessárias). 25

6 2 Semântica Operacional e Sistemas de Tipos Mais açucar sintático (42) Note que o operador de sequência ';' e a construção while poderiam ser simulados através de funções: e 1 ; e 2 pode ser codificado como (fn y:unit e 2 ) e 1 onde y fv(e 2 ) while e 1 do e 2 poderia ser codificado como: l e t r e c w: unit > unit = fn y : unit => i f e 1 then (e 2 ; (w skip ) ) else skip in w skip end para um novo w e y fv(e 1 ) fv(e 2 ) Propriedades de L2 Assim como L1, a linguagem L2 é determinística e o enunciado do teorema que afirma essa propriedade é o mesmo. O enunciado das propriedades de preservação e progresso na essência são os mesmos mas neles assumimos que as expressões em consideração são expressões fechadas, ou seja, expressões onde não há variáveis não declaradas. Progresso e Preservação (43) Teorema 5 (Progresso) Se e : T, então e é um valor ou existe e ; σ e, σ e, σ. tal que Teorema 6 (Preservação) Se e : T e e, σ e, σ então e : T. Todos os resultados sobre os problemas da tipabilidade e da verificação de tipos de L1 permancem os mesmos para L2. 26