Upload
guilherme-polo
View
584
Download
0
Embed Size (px)
Citation preview
COMPARATIVO ENTRE LINGUAGENS
vs.
Alexandre Moreno, Cássio Korogui, Daniel Hey, Guilherme PoloJulho, 2010
1
HISTÓRICO
2
HISTÓRICO
• Começou a ser projetada em 2007 na Google.
• Projetistas: Ken Thompson, Robert Griesemer, Rob Pike.
• Objetivo: Combinar a facilidade de uma linguagem interpretada e dinamicamente tipada com a eficiência e segurança de uma linguagem compilada e estaticamente tipada.
• Finalidade: Servir como uma nova linguagem para programação de sistemas.
Linguagem Go
3
HISTÓRICO
• Paradigmas: concorrente, imperativo, orientado a objetos.
• Influências:
• C: similaridades com a sintaxe;
• Pascal/Modula/Oberon: declarações e pacotes;
• Linguagem formal CSP (Limbo/Alef): concorrência
Linguagem Go
4
HISTÓRICO
• Criada em 1993 na Tecgraf, PUC-RIO.
• Projetistas: Roberto Ierusalimschy, Luiz Henrique de Figueiredo e Waldemar Celes.
• Surgiu a partir da idéia de que duas linguagens previamente desenvolvidas na Tecgraf poderiam ser combinadas e aumentadas para formar uma linguagem de uso geral.
• DEL (Data Entry Language) e SOL (Simple Object Language) eram essas linguagens.
Linguagem Lua
5
HISTÓRICO
• Objetivo: Criar uma linguagem altamente portável, genérica, pequena e simples na forma de uma biblioteca.
• Finalidade:
• Permitir que programas já existentes pudessem a incorporar ;
• Servir como alternativa a linguagens existentes na época com propósito similar (LISP, Python, Scheme, Tcl).
• Paradigmas: funcional, imperativo, orientado a objetos (protótipo).
Linguagem Lua
6
HISTÓRICO
• Influências:
• SOL: sintaxe para construção de registros e listas. Também herdou o conceito de ser implementado como uma biblioteca;
• Modula: sintaxe para estruturas de controle while, if e repeat until;
• CLU: atribuição múltipla e funções que retornam múltiplos valores;
• C++: idéia de que uma variável local pode ser declarada onde ela é utilizada;
• SNOBOL/Awk: arrays associativos, chamados de tabelas em Lua.
Linguagem Lua
7
HISTÓRICO
Tempo de vida
Principal uso
Paradigmas
2 anos 16 anos
Programação de sistemas
Extensão
Concorrente, imperativo, orientado a
objetos
Funcional, imperativo, orientado a
objetos
Uso interno naGoogle
•Scripts para nmap;•Customização de Interface no WoW;•Configuração, UI, e outros no SimCity 4; •Customização do comportamento do Monotone;•...
8
TIPOS DE DADOS
9
TIPOS DE DADOS
• A linguagem Lua conta com apenas 8 tipos:
• nil, boolean, number, string, userdata, thread, function e table.
números reais (internamente: ponto flutuante de precisão dupla)
cadeia de caracteres de 8 bits
array associativo
diferente de qualquer outro valor, utilizado para representar ausência de um valor útil
bloco de memória vindo de um aplicativo em C
representa fluxos de execução independentes,utilizado para implementar corotinas
10
TIPOS DE DADOS
• A linguagem Lua conta com apenas 8 tipos:
• nil, boolean, number, string, userdata, thread, function e table.
• Por outro lado, Go disponibiliza 28 tipos:
• bool, string, array, struct, pointer, function, interface, slice, map, channel;
array de caracteres unicode codificados em UTF-8 (representação interna em bytes)
array associativo
fornece um mecanismo de sincronização entre duas funções em execução concorrente
tipo dinâmico
11
TIPOS DE DADOS
• A linguagem Lua conta com apenas 8 tipos:
• nil, boolean, number, string, userdata, thread, function e table.
• Por outro lado, Go disponibiliza 28 tipos:
• bool, string, array, struct, pointer, function, interface, slice, map, channel;
• Numéricos: uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, complex64, complex128, byte (alias para uint8), uint, int, float, complex, uintptr.
12
TIPOS DE DADOS
• As duas linguagens fornecem um tipo string imutável.
• Em Lua, operações com strings são realizadas através da biblioteca “string” da linguagem.
• Versões mais recentes da linguagem (5.1+) permitem um estilo orientado a objetos: minhastr:lower() ao invés de string.lower(minhastr).
• Go também contém um pacote (biblioteca) para manipulação de strings. Porém optou-se por usar uma função “len”, fora desse pacote, para comprimento de string e outros objetos que podem ter seu tamanho obtido.
Strings
13
TIPOS DE DADOS
• Ambas linguagens dispõem de um tipo para as funções declaradas, tratando-as como objetos de primeira classe (em Lua todos os valores são de primeira classe).
• Isso significa que (SICP):
• Funções podem ser passadas como argumentos;
• Podem ser retornadas como resultado;
• Podem ser nomeadas por uma variável qualquer;
• Também podem ser inclusas em estruturas de dados.
Funções
14
TIPOS DE DADOS
• Go disponibiliza o tipo array para se construir arrays, enquanto que Lua utiliza o tipo table para simular arrays.
• As duas linguagens aceitam valores inteiros como subscritos, sendo que em Go o índice inicia em 0 enquanto que na outra inicia-se 1.
• Isso é válido em Lua somente enquanto não utilizamos nenhum “recurso” adicional das tabelas, isto é:
x = {1, 2, 3}; print(x[1])
x = {[0] = 1, 2, 3}; print(x[1])
Arrays
“1”
“2”
15
TIPOS DE DADOS
• Em Go, arrays são especificadas com uma expressão constante que define seu tamanho. Ex.: var ponto [3]int
• Em tempo de compilação é verificado se acessos com expressões constantes não ultrapassam o limite da array;
• Em tempo de execução os outros casos de acesso são verificados.
• Em Lua, arrays são dinâmicos no heap. Ao acessar uma posição que não pertence ao array é retornado nil.
Arrays
16
TIPOS DE DADOS
• Arrays podem ser inicializadas no momento da declaração nas duas linguagens:
• Go: z := [10]int {1, 2, 3}
• Lua: z = {1, 2, 3}
• Na Go, os outros elementos (de 3 a 9) são inicializados em 0.
• A linguagem também permite especificar posições específicas para serem inicializadas:
z := [10]int {0:1, 2:2, 4:3}
Arrays
17
TIPOS DE DADOS
• A biblioteca “table” da Lua fornece operações como de concatenação (de elementos de uma tabela/array) e ordenação.
• Go optou por realizar ordenação através de um pacote chamado “sort”.
• Qualquer coleção pode ser ordenada se ela implementa a interface sort.Interface.
• Slices em Go utilizam a sintaxe x[inicio:fim], com semântica [inicio:fim), onde x é um array, string, ou mesmo um slice. Lua não disponibiliza slices.
Arrays
18
TIPOS DE DADOS
• Nenhuma dessas linguagens tem naturalmente o conceito de arrays multidimensionais como se vê em Matlab (por exemplo).
• Porém, as duas fornecem meios alternativos:
• Go: var x [2][3]float
• Lua: x = {{}, {}}
• Operações nesses arrays devem ser feitas individualmente em cada dimensão.
Arrays Multidimensionais
19
TIPOS DE DADOS
• O tipo table em Lua é utilizado para se criar arrays associativos, Go utiliza o tipo map para essa finalidade.
• Porém, Lua permite que esse tipo contenha pares chave/valor de todos os tipos (exceto nil como chave) enquanto Go limita o tipo do par chave/valor ao especificado na declaração.
• tables são utilizadas também para criar registros, arrays comuns, e outros tipos de estruturas. Tabelas são o único mecanismo de estruturação de dados em Lua.
Arrays Associativos
20
TIPOS DE DADOS
• As duas implementações permitem arrays associativos de tamanho dinâmico.
• O acesso à elementos ocorre de forma similar à acesso de elementos de arrays – por subscrito.
• A diferença é que os índices não precisam ser inteiros;
• Na linguagem Go, é possível fazer uso da atribuição múltipla para obter informação adicional;
• Lua permite uma notação adicional para acesso, equivalente ao acesso de campos de um registro em C.
Arrays Associativos
21
TIPOS DE DADOS
• Lua não disponibiliza ponteiros, fato comum a linguagens de sua classe.
• Go possui o tipo uintptr, que é capaz de armazenar um endereço qualquer. Diferentemente de C, não há aritmética de ponteiros:
• Com isso, não é possível derivar endereços ilegais;
• Simplifica a implementação do coletor de lixo da linguagem.
• Também não há ponteiros pendurados (dangling pointers) em Go.
Ponteiros
22
TIPOS DE DADOS
• Porém, o seguinte código compila:
var bp *int = nil; print(*bp)
Ponteiros
atribui nil para o ponteiro bp
dereferencia bp para imprimirrepresentação da memória apontada
23
TIPOS DE DADOS
• Porém, o seguinte código compila:
var bp *int = nil; print(*bp)
• Em tempo de execução:
• panic: runtime error: invalid memory address or nil pointer dereference
• “Null References: The Billion Dollar Mistake” - Tony Hoare
Ponteiros
24
VERIFICAÇÃO DE TIPOS
25
VERIFICAÇÃO DE TIPOS
• Go é quase fortemente tipada.
• Pacote “unsafe” incluso na linguagem permite violar o sistema de verificação de tipos.
• Lua é fracamente tipada.
• Linguagem tenta fazer a coerção de string para number em operações aritméticas:
print("1" + 1, "1" + "1.e7")
print("1" + "a")
“2 10000001”
attempt to perform arithmetic on a string value
26
VERIFICAÇÃO DE TIPOS
• Go é quase fortemente tipada.
• Pacote “unsafe” incluso na linguagem permite violar o sistema de verificação de tipos.
• Lua é fracamente tipada.
• Linguagem tenta fazer a coerção de string para number em operações aritméticas.
• Quantidade de argumentos passados para uma função não é levado em conta. Um argumento formal é nil se ele não receber um valor ; e argumentos extras são simplesmente ignorados.
27
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
28
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
* / % << >> & &^ ^+ - | ^ not # -
!= == < <= > >= * / %<- + -&& ..|| < > <= >= ˜= ==
andor
Regras de Precedência
unário
Menor
exponenciação
tamanho
concatenação
!=
xorou bitwise not unário
bit clear (bitwise and not)
especifica direção de um tipo
channel
29
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
• Na linguagem Lua, os operadores de concatenação (“..”) e exponenciação (“^”) são associativos a direita. Demais operadores são associativos a esquerda.
• Todos os operadores em Go são associativos a esquerda.
• As duas linguagens permitem o uso de parênteses para forçar outra ordem de precedência.
Regras de Associação
30
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
• A linguagem Go não oferece recursos para sobrecarga de operadores.
• Através de meta métodos em meta tabelas, Lua permite sobrecarregar operadores.
Sobrecarga de Operadores
pt1 = {x=3, y=2}; pt2 = {x=2, y=-1}
function pt_add (a, b) return {x = a.x+b.x, y = a.y+b.y}endmetatabela = {__add = pt_add}setmetatable(pt1, metatabela)
pt3 = pt1 + pt2print(pt3.x, pt3.y) “5 1”
31
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃOCoerções
• Go não fornece conversões implícitas entre tipos numéricos.
• Tipos int e int32 são considerados como tipos distintos mesmo numa arquitetura de 32 bits;
var x int = 6var y int32 = 4print(x + y) invalid operation: x + y (type int + int32)
32
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
• Go não fornece conversões implícitas entre tipos numéricos.
• Tipos int e int32 são considerados como tipos distintos mesmo numa arquitetura de 32 bits;
• Lua representa todos os números num programa com um único tipo: number. Logo não há coerções entre tipos numéricos.
• Porém, um tipo string sofre coerção quando um operador aritmético é aplicado.
Coerções
33
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
• Lua e Go diferem apenas no operador “não igual”:
• A primeira utiliza ~= e a outra !=
• As duas linguagens produzem um valor de tipo booleano.
• Os operadores relacionais (<, >, <=, >=, ˜=, ==) em Lua não utilizam a coerção de string para number.
• Na linguagem Go, os operadores == e != podem ser aplicados a quase todos os tipos (exceto array e struct).
• Demais operadores (<, >, <=, >=) podem ser aplicados somente a inteiros, ponto flutuante e strings.
Expressões Relacionais
34
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
• Todos os operadores lógicos em Go (&&, ||) e em Lua (and, or) são avaliados em curto-circuito.
• Operadores lógicos em Lua não podem ser sobre carregados (não há meta métodos previstos para eles), garantindo a avaliação curto circuito.
Avaliação Curto-Circuito
35
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
• Tem a seguinte sintaxe:
• var {, var} = exp {, exp}
• Aceita atribuições múltiplas;
• Se houver mais expressões que variáveis, elas são descartadas;
• Se houver mais variáveis que expressões, as excedentes recebem nil;
• Operadores compostos não são aceitos.
• Atribuição não é tratada com uma expressão.
Atribuição em Lua
Não-terminal
Elemento EBNF
Terminal
36
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
• Tem a seguinte sintaxe:
• exp {, exp} [add_op | mul_op] = exp {, exp}
• Aceita atribuições múltiplas;
• Lado esquerdo e direito devem conter a mesma quantidade de valores após as expressões serem avaliadas;
• Aceita operadores compostos.
• Atribuição não é tratada com uma expressão.
• Cada atribuição deve ser compatível.
Atribuição em Go
+ | - | | |^
*| / | % | << | >> | & | &^
http://golang.org/doc/go_spec.html#Properties_of_types_and_values
37
ESTRUTURAS DE CONTROLE
38
ESTRUTURAS DE CONTROLE
• Estruturas de controle em Lua não possuem múltiplas entradas.
• Go disponibiliza a declaração goto, logo todas as estruturas de controle podem possuir múltiplas entradas.
• Declarações rotuladas podem ser alvo tanto do goto quanto de break e continue.
• Uma restrição: executar um goto não pode alterar o ambiente de referenciamento.
goto exitresultado := 3exit:
Erro! Ao pular para exit, resultado passou a fazer parte do escopo
39
ESTRUTURAS DE CONTROLE
• Sintaxe geral em Lua:
• if exp then bloco {elseif exp then bloco} [else bloco] end
• Aceita uma expressão qualquer (aritmética, lógica, construtor de tabela, ...);
• Se exp for avaliada como false ou nil, a expressão é tida como falsa.
Seleção bidirecional
40
ESTRUTURAS DE CONTROLE
• Sintaxe geral em Go:
• if [simplestmt ;] [expressão] { {stmt ;} } [else stmt]
Seleção bidirecional
Permite realizar atribuição, declarar novas variáveis, incrementar/decrementar variável ou uma expressão qualquer antes de avaliar a expressão de condição.
expressão condicionalaritmética/lógica
41
ESTRUTURAS DE CONTROLE
• Em Lua é possível realizar seleção múltipla somente através da combinação de seletores bidirecionais.
• Go disponibiliza switch em duas formas:
• switch de expressões;
• switch de tipos.
Seleção múltipla
42
ESTRUTURAS DE CONTROLE
• Sintaxe geral de switch de expressões:
• switch [simplestmt ;] [expressão] { {exprSwitchCase : {stmt ;}} }
Seleção múltipla em Go
case expressão {, expressão} default
43
ESTRUTURAS DE CONTROLE
• Sintaxe geral de switch de expressões:
• switch [simplestmt ;] [expressão] { {exprSwitchCase : {stmt ;}} }
• Expressões de uma cláusula não precisam ser constantes; são avaliadas da esquerda para direita e de cima para baixo.
Seleção múltipla em Go
44
ESTRUTURAS DE CONTROLE
• Sintaxe geral de switch de expressões:
• switch [simplestmt ;] [expressão] { {exprSwitchCase : {stmt ;}} }
• Somente a última instrução de uma cláusula default ou case pode ser a declaração fallthrough, indicando que o controle deve ser passado para o início da próxima cláusula.
• Caso fallthrough não seja utilizado, controle é desviado para o final do switch.
Seleção múltipla em Go
45
ESTRUTURAS DE CONTROLE
• Sintaxe geral de switch de tipos:
• switch [simplestmt ;] typeSwitchGuard {{typeSwitchCase : {stmt ;}}}
Seleção múltipla em Go
case type {, type} default
[ident :=] primaryExp . ( type )
46
ESTRUTURAS DE CONTROLE
• Sintaxe geral de switch de tipos:
• switch [simplestmt ;] typeSwitchGuard {{typeSwitchCase : {stmt ;}}}
• Esse tipo de switch compara tipos ao invés de valores.
• Declaração fallthrough não é permitida aqui.
Seleção múltipla em Go
47
ESTRUTURAS DE CONTROLE
• Lua disponibiliza duas formas para o comando for, uma delas é a versão numérica:
• for ident = exp1, exp2 [, exp3] do bloco end
• Iteração inicia com valor de exp1, prosseguindo até exp2 com passos de tamanho exp3;
• Se exp3 for omitida, o passo é 1;
• As três (ou duas) expressões são avaliadas antes do laço iniciar e todas devem produzir números;
• A variável criada com nome ident é local ao laço.
Laços controlados por contador
48
ESTRUTURAS DE CONTROLE
• Go disponibiliza quatro formas para o comando for, uma delas pode ser utilizada como numérica:
• for [simplestmt1] ; [expressão] ; [simplestmt2] { {stmt ;} }
• simplestmt1 pode conter declaração de variável, simplestmt2 não;
• variável(is) declarada(s) em simplestmt1 tem escopo local ao for e podem ser alteradas dentro do bloco;
• A expressão é avaliada no início de cada iteração, simplestmt1 somente no início do laço e simplestmt2 após cada execução do bloco;
• Se expressão for omitida, é um loop infinito;
Laços controlados por contador
49
ESTRUTURAS DE CONTROLE
• Lua disponibiliza duas formas, separando instruções de pré-teste e pós-teste:
• repeat bloco until exp
• while exp do bloco end
• Duas formas do for da Go servem para controle de repetição baseada em expressão booleana:
• Na forma do slide anterior, basta omitir a primeira e última parte opcional;
• A outra forma utiliza pré-teste também: for expressao { {stmt ;} }
Laços controlados logicamente
50
ESTRUTURAS DE CONTROLE
• As duas linguagens disponibilizam break e continue com a semântica usual.
• Go permite rotular declarações e permite que break e continue transfiram o controle para um rótulo específico.
• No caso do break rotulado, o rótulo deve preceder um for para indicar que o mesmo será encerrado;
• No caso do continue rotulado, o rótulo deve preceder um for para indicar que o mesmo terá sua execução “pulada”.
Controle de laço localizado pelo usuário
51
ESTRUTURAS DE CONTROLE
• A segunda forma do for disponibilizada pela Lua tem a seguinte sintaxe:
• for ident {, ident} in exp {, exp} do bloco end
• As expressões são avaliadas uma única vez;
• Os identificadores criados para guardar os resultados das expressões são locais ao laço;
Laços baseados em estrutura de dados
for k,v in pairs({42, a = "A"}) do print(k,v)end
for k,v in next,{42, a = "A"} do print(k,v) end
equivalentes
52
ESTRUTURAS DE CONTROLE
• A terceira forma do for da linguagem Go é utilizada para iterar sobre todas os elementos de um array, string, slice, map ou valores recebidos em um channel.
• for expressão {, expressão} (=|:=) range expressão
• Ao utilizar a forma com := as variáveis criadas deixam de existir no final do laço;
Laços baseados em estrutura de dados
um desses tipos
x := [3]int{1, 2, 3}sum := 0for _, v := range x { sum += v}
ignora índicesretornados
53
ESTRUTURAS DE CONTROLE
• Não disponível em Lua.
• Go disponibiliza a instrução select:
• Entre um conjunto de comunicações possíveis, escolhe uma para prosseguir ;
• Sintaxe parecida com switch.
Comandos Protegidos
select { { commCase : { stmt ; } } }
case (recvExpr | sendExpr) default
expr <- expr[ expr (=|:=) ] <- expr
54
ESTRUTURAS DE CONTROLEComandos Protegidos em Go
• Exemplo:package mainfunc main() { canal := make(chan int); go func() { for { print(<-canal) } }();
for { select { case canal <- 0: case canal <- 1: } }}
001000010000100011101010110111010011001001100001011000010001111100011101110110000010001001001010010111111011011010110010001110111010001111011101101011101101110010111010011110101111001011011100110001011010110100011010100100000010110110011000000101000100011010001010110110101011011001100111010000111000000011100000000101010101011000011111001001100010100001000111011000111010011100001010100100111100010011100100110010111101110010000000111111011010011001101110111100101101110001111001000110000110101111100001010011001011011010110101001000001000110110001100111000100000010010001011010001011001000000111100000000010100011001101101111111110000110000011010001101000000101111011011100100101100...
55
ESTRUTURAS DE CONTROLE
• Todas as expressões recvExpr e sendExpr são avaliadas, assim como o lado direito das sendExprs, de cima para baixo.
1. Se qualquer uma das comunicações puderem proceder, uma é escolhida e a respectiva comunicação juntamente com seu bloco de instruções são avaliados;
2. Se nenhuma comunicação puder proceder ...
2.1. e se houver uma cláusula default, então ela é executada;
2.2. e não houver uma cláusula default, o select bloqueia até o momento que alguma comunicação puder proceder.
Comandos Protegidos em Go
56
MODULARIZAÇÃO
57
MODULARIZAÇÃO
• As duas linguagens permitem modularização através da sub-programação.
• gorotinas e funções em Go;
• corotinas e funções em Lua.
• Além disso Go separa os programas em pacotes, obrigatoriamente.
• Lua permite a criação de módulos.
58
MODULARIZAÇÃO
• Início de um programa é definido como a função chamada “main” contida no pacote “main”*.
• Todo arquivo pertence a um pacote, e um pacote pode ser formado por vários arquivos.
• Um arquivo pode importar outros pacotes.
• Apenas identificadores que declaram constantes, tipos, variáveis ou funções e que iniciam com letra maiúscula são exportados.
Pacotes Go
59
MODULARIZAÇÃO
• Para carregar módulos a função require ou loadlib podem ser utilizadas.
• A primeira é frequentemente utilizada para carregar módulos escritos puramente em Lua;
• A segunda é necessária para carregar módulos escritos em C na forma de biblioteca (.DLL, .so, .dylib, ...).
Módulos Lua
60
MODULARIZAÇÃO
• Módulos podem ser criados de várias formas.
• Exemplo:
Módulos Lua
modulo = {}function modulo.oi() print("oi") endreturn modulo
require "melancia"abacate = require "abacate"abacate.oi()melancia.oi()
module("melancia", package.seeall)function oi() print("oi oi") end
mai
n.lu
a
abacate.luamelancia.lua
61
MODULARIZAÇÃO
• Módulos podem ser criados de várias formas.
• Exemplo:
• A partir da versão 5.1 existe a função module para facilitar a criação de módulos.
• Elimina código boilerplate;
• Símbolos que não devem ser exportados precisam ser precedidos de local. Ex.: local x = 3
Módulos Lua
62
POLIMORFISMO
63
POLIMORFISMO
• Em Go, interfaces são utilizadas para obter polimorfismo universal de subtipo.
• Interfaces definem um conjunto de métodos.
• Um tipo automaticamente “implementa” uma interface se possuir um super-conjunto dos métodos definidos na interface.
• Um parâmetro de tipo interface aceita qualquer tipo que a implementa.
64
POLIMORFISMO
• Em Go, interfaces são utilizadas para obter polimorfismo universal de subtipo.
package main
type StrInterface interface { str() string }type Rã inttype Pato int
func (t *Rã) str() string { return "croac" }func (t *Pato) str() string { return "quack" }
func imprime(item StrInterface) { println(item.str()) }
func main() { var r *Rã var p *Pato imprime(r); imprime(p)}
croacquack
Palavra reservada
Tipo built-in
Nome de função
String
Outros
65
POLIMORFISMO
• Em Lua, há polimorfismo universal paramétrico implícito – comum nas linguagens dinamicamente tipadas.
function imprime(item) print(item:str()) end
Ran = {}ran_mt = {__index = Ran}
function Ran:new() return setmetatable({}, ran_mt) endfunction Ran:str() return "croak" end
r = Ran:new()imprime(r)imprime({str = function () return "quack" end})
66
TIPOS ABSTRATOS DE DADOS
67
TIPOS ABSTRATOS DE DADOS
package bintree
type nó struct { valor int esq, dir *nó}
func NovaÁrvore(valor int) *nó { t := new(nó); t.valor = valor; return t }
func (self *nó) EmOrdem() { em_ordem(self) }
func (self *nó) Insere(valores ... int) { for i := 0; i < len(valores); i++ { insere(self, valores[i]) }}
package main
import "./bintree"
func main() { arvore := bintree.NovaÁrvore(42) arvore.Insere(11, 43, 13, 7) arvore.EmOrdem()}
Exemplo em Go
68
TIPOS ABSTRATOS DE DADOS
package bintree
type nó struct { valor int esq, dir *nó}
func NovaÁrvore(valor int) *nó { t := new(nó); t.valor = valor; return t }
func (self *nó) EmOrdem() { em_ordem(self) }
func (self *nó) Insere(valores ... int) { for i := 0; i < len(valores); i++ { insere(self, valores[i]) }}
Exemplo em Gofunc em_ordem(x *nó) { if x.esq != nil { em_ordem(x.esq) } println(x.valor) if x.dir != nil { em_ordem(x.dir) }}func insere(x *nó, v int) *nó { if x == nil { x = NovaÁrvore(v) } else if v < x.valor { x.esq = insere(x.esq, v) } else x.dir = insere(x.dir, v) return x}
69
TIPOS ABSTRATOS DE DADOS
module("bintree", package.seeall)
arvore = {}local mt = {__index = arvore}
function arvore:nova(valor) return setmetatable({valor = valor, esq = nil, dir = nil}, mt)end
function arvore:em_ordem() em_ordem(self) end
function arvore:insere(...) for i = 1, #arg do insere(self, arg[i]) end end
require "bintree"
x = bintree.arvore:nova(42)x:insere(11, 43, 13, 7)x:em_ordem()
Exemplo em Lua
70
TIPOS ABSTRATOS DE DADOS
module("bintree", package.seeall)
arvore = {}local mt = {__index = arvore}
function arvore:nova(valor) return setmetatable({valor = valor, esq = nil, dir = nil}, mt)end
function arvore:em_ordem() em_ordem(self) end
function arvore:insere(...) for i = 1, #arg do insere(self, arg[i]) end end
Exemplo em Lualocal function em_ordem(x) if x.esq ~= nil then em_ordem(x.esq) end print(x.valor) if x.dir ~= nil then em_ordem(x.dir) endendlocal function insere(x, v) if x == nil then x = arvore:nova(v) elseif v < x.valor then x.esq = insere(x.esq, v) else x.dir = insere(x.dir, v) end return xend
71
TIPOS ABSTRATOS DE DADOS
Como definir um TAD
Encapsulamento
Visibilidade
1. Criar um tipo;2. Definir métodos
para o tipo.
1. Criar uma meta tabela para o tipo;2. Definir funções
com prefixo “tipo”.
Pacotes Módulos
Somente identificadores exportados são
visíveis
Não permite ocultar acesso a atributos
do tipo
72
REFERÊNCIAS• Blow, J. (2004). Game development: Harder than you think. ACM Queue, pages 31–32.
• Cardelli, L. and Wegner, P. (1985). On understanding types, data abstraction, and polymorphism. ACM Computing Surveys, 17:471–522.
• Dijkstra, E. W. (1975). Guarded commands, non-determinacy and a calculus for the derivation of programs. In Proceedings of the international conference on Reliable software, New York, NY, USA. ACM.
• Gabbrielli, M. and Martini, S. (2010). Programming Languages: Principles and Paradigms, chapter 9, pages 265–275. Springer.
• Go (2010a). The go programming language specification. http://golang.org/doc/go_spec.html. Acessado em 16 de Junho de 2010.
• Go (2010b). Language design faq. http://golang.org/doc/go_lang_faq.html. Acessado em 16 de Junho de 2010.
• Hoare, T. (2009). Null references: The billion dollar mistake. Apresentado na QCon London.
• Ierusalimschy, R., de Figueiredo, L. H., and Celes, W. (2006). Lua 5.1 Reference Manual. Lua.org.
• Ierusalimschy, R., de Figueiredo, L. H., and Celes, W. (2007). The evolution of lua. In: HOPL III: Proceedings of the third ACM SIGPLAN conference on History of programming languages. ACM Press.
• Sebesta, R. W. (2001). Concepts of Programming Languages. Addison Wesley, 5th edition.
• Taivalsaari, A. (1996). Classes vs. prototypes - some philosophical and historical observations. In Journal of Object-Oriented Programming, pages 44–50. SpringerVerlag.
73