Você está na página 1de 73

1

COMPARATIVO ENTRE LINGUAGENS

vs.

Alexandre Moreno, Cássio Korogui, Daniel Hey, Guilherme Polo


Julho, 2010
2

HISTÓRICO
3

HISTÓRICO
Linguagem Go
• 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.
4

HISTÓRICO
Linguagem Go
• 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


5

HISTÓRICO
Linguagem Lua
• 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.
6

HISTÓRICO
Linguagem Lua
• 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).


7

HISTÓRICO
Linguagem Lua
• 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.


8

HISTÓRICO •Scripts para nmap;


•Customização de
Interface no WoW;
•Configuração, UI, e
outros no SimCity 4;
•Customização do
comportamento do
Monotone;
•...
Tempo de
2 anos 16 anos
vida
Uso interno na Principal Programação
Google Extensão
uso de sistemas
Concorrente, Funcional,
imperativo, imperativo,
Paradigmas
orientado a orientado a
objetos objetos
9

TIPOS DE DADOS
10

TIPOS DE DADOS

•A linguagem Lua conta com apenas 8 tipos:

• nil, boolean, number, string, userdata, thread, function e table.

array associativo
representa fluxos de execução independentes,
utilizado para implementar corotinas
bloco de memória vindo de um aplicativo em C
cadeia de caracteres de 8 bits
números reais (internamente: ponto flutuante de precisão dupla)
diferente de qualquer outro valor, utilizado para representar ausência
de um valor útil
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;

array de caracteres unicode codificados em UTF-8 array associativo


(representação interna em bytes)
fornece um mecanismo de sincronização entre duas tipo dinâmico
funções em execução concorrente
12

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.
13

TIPOS DE DADOS
Strings
• 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.
14

TIPOS DE DADOS
Funções
• 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.


15

TIPOS DE DADOS
Arrays
• 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]) “1”
x = {[0] = 1, 2, 3}; print(x[1]) “2”
16

TIPOS DE DADOS
Arrays
• EmGo, 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.
17

TIPOS DE DADOS
Arrays
• 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}


18

TIPOS DE DADOS
Arrays
•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.
19

TIPOS DE DADOS
Arrays Multidimensionais
• 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çõesnesses arrays devem ser feitas individualmente em


cada dimensão.
20

TIPOS DE DADOS
Arrays Associativos
•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.

são utilizadas também para criar registros, arrays


• tables
comuns, e outros tipos de estruturas. Tabelas são o único
mecanismo de estruturação de dados em Lua.
21

TIPOS DE DADOS
Arrays Associativos
• 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.
22

TIPOS DE DADOS
Ponteiros
• 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.
23

TIPOS DE DADOS
Ponteiros
• Porém, o seguinte código compila:
var bp *int = nil; print(*bp)

dereferencia bp para imprimir


representação da memória apontada

atribui nil para o ponteiro bp


24

TIPOS DE DADOS
Ponteiros
• Porém, o seguinte código compila:
var bp *int = nil; print(*bp)

• Em tempo de execução:

• panic: runtimeerror: invalid memory


address or nil pointer dereference

• “NullReferences: The Billion Dollar


Mistake” - Tony Hoare
25

VERIFICAÇÃO DE TIPOS
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:

print("1" + 1, "1" + "1.e7") “2 10000001”


print("1" + "a") attempt to perform arithmetic on a string value
27

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.
28

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


29

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


Regras de Precedência

exponenciação
bit clear
(bitwise and not) tamanho
xor * / % << >> & &^ ^
unário
ou bitwise not unário + - | ^ not # -

especifica direção != == < <= > >= * / %


de um tipo <- + -
channel && .. concatenação
|| < > <= >= ˜= ==
!=
and
Menor or
30

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


Regras de Associação
• Nalinguagem 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.

• Asduas linguagens permitem o uso de parênteses para forçar


outra ordem de precedência.
31

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


Sobrecarga de Operadores
•A linguagem Go não oferece recursos para sobrecarga de
operadores.

• Atravésde meta métodos em meta tabelas, Lua permite


sobrecarregar 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}
end
metatabela = {__add = pt_add}
setmetatable(pt1, metatabela)

pt3 = pt1 + pt2


print(pt3.x, pt3.y) “5 1”
32

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


Coerçõ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 = 6
var y int32 = 4
print(x + y) invalid operation: x + y (type int + int32)
33

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


Coerçõ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;

• 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.
34

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


Expressões Relacionais
• 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.
35

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


Avaliação Curto-Circuito
• 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.
36

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


Atribuição em Lua
• Tem a seguinte sintaxe:
Não-terminal
• var {, var} = exp {, exp} Elemento EBNF
Terminal
• 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.


37

EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO


Atribuição em Go
• 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.


http://golang.org/doc/go_spec.html#Properties_of_types_and_values
38

ESTRUTURAS DE CONTROLE
39

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 exit
resultado := 3 Erro! Ao pular para exit, resultado
exit: passou a fazer parte do escopo
40

ESTRUTURAS DE CONTROLE
Seleção bidirecional
• 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 expfor avaliada como false ou nil, a expressão é tida


como falsa.
41

ESTRUTURAS DE CONTROLE
Seleção bidirecional
• Sintaxe geral em Go:
• if [simplestmt ;] [expressão] { {stmt ;} } [else stmt]

expressão condicional
aritmética/lógica

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.
42

ESTRUTURAS DE CONTROLE
Seleção múltipla
• 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.
43

ESTRUTURAS DE CONTROLE
Seleção múltipla em Go
• Sintaxe geral de switch de expressões:
• switch [simplestmt ;] [expressão] { {exprSwitchCase : {stmt ;}} }

case expressão {, expressão} default


44

ESTRUTURAS DE CONTROLE
Seleção múltipla em Go
• 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.
45

ESTRUTURAS DE CONTROLE
Seleção múltipla em Go
• 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.
46

ESTRUTURAS DE CONTROLE
Seleção múltipla em Go
• Sintaxe geral de switch de tipos:
• switch [simplestmt ;] typeSwitchGuard {{typeSwitchCase : {stmt ;}}}

case type {, type} default

[ident :=] primaryExp . ( type )


47

ESTRUTURAS DE CONTROLE
Seleção múltipla em Go
• 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.


48

ESTRUTURAS DE CONTROLE
Laços controlados por contador
• 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.


49

ESTRUTURAS DE CONTROLE
Laços controlados por contador
• 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;


50

ESTRUTURAS DE CONTROLE
Laços controlados logicamente
• 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 ;} }


51

ESTRUTURAS DE CONTROLE
Controle de laço localizado pelo usuário
• 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”.
52

ESTRUTURAS DE CONTROLE
Laços baseados em estrutura de dados
•Asegunda 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;

• Osidentificadores criados para guardar os resultados das


expressões são locais ao laço;
equivalentes
for k,v in pairs({42, a = "A"}) do for k,v in next,{42, a = "A"} do
print(k,v) print(k,v)
end end
53

ESTRUTURAS DE CONTROLE
Laços baseados em estrutura de dados
•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. um desses tipos

• 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;
x := [3]int{1, 2, 3}
sum := 0
for _, v := range x {
ignora índices
retornados sum += v
}
54

ESTRUTURAS DE CONTROLE
Comandos Protegidos
• Não disponível em Lua.

• Go disponibiliza a instrução select:

• Entreum conjunto de comunicações possíveis, escolhe uma


para prosseguir;

• Sintaxe parecida com switch.


select { { commCase : { stmt ; } } }

case (recvExpr | sendExpr) default

[ expr (=|:=) ] <- expr expr <- expr


55

ESTRUTURAS DE CONTROLE
Comandos Protegidos em Go
• Exemplo:
package main 00100001000010001110101011011101001100
10011000010110000100011111000111011101
func main() { 10000010001001001010010111111011011010
canal := make(chan int); 11001000111011101000111101110110101110
11011100101110100111101011110010110111
go func() { 00110001011010110100011010100100000010
for { print(<-canal) } 11011001100000010100010001101000101011
}(); 01101010110110011001110100001110000000
11100000000101010101011000011111001001
10001010000100011101100011101001110000
for { 10101001001111000100111001001100101111
01110010000000111111011010011001101110
select { 11110010110111000111100100011000011010
case canal <- 0: 11111000010100110010110110101101010010
case canal <- 1: 00001000110110001100111000100000010010
00101101000101100100000011110000000001
} 01000110011011011111111100001100000110
} 10001101000000101111011011100100101100
...
}
56

ESTRUTURAS DE CONTROLE
Comandos Protegidos em Go
• 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.
57

MODULARIZAÇÃO
58

MODULARIZAÇÃO

• Asduas 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.


59

MODULARIZAÇÃO
Pacotes Go
• Início
de um programa é definido como a função chamada
“main” contida no pacote “main”*.

• Todoarquivo 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.
60

MODULARIZAÇÃO
Módulos Lua
• Paracarregar módulos a função require ou loadlib podem
ser utilizadas.

•Aprimeira é 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, ...).
61

MODULARIZAÇÃO
Módulos Lua
• Módulos podem ser criados de várias formas.

• Exemplo:
abacate.lua
melancia.lua modulo = {}
module("melancia", package.seeall) function modulo.oi()
function oi() print("oi")
print("oi oi") end
end return modulo

require "melancia"
abacate = require "abacate"
main.lua

abacate.oi()
melancia.oi()
62

MODULARIZAÇÃO
Módulos Lua
• 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
63

POLIMORFISMO
64

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.
65

POLIMORFISMO

• Em Go, interfaces são utilizadas para obter polimorfismo


universal de subtipo.
package main
Palavra reservada
type StrInterface interface { str() string } Tipo built-in
type Rã int
Nome de função
type Pato int
String
func (t *Rã) str() string { return "croac" } Outros
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)
croac
} quack
66

POLIMORFISMO

• EmLua, 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) end


function Ran:str() return "croak" end

r = Ran:new()
imprime(r)
imprime({str = function () return "quack" end})
67

TIPOS ABSTRATOS DE DADOS


68

TIPOS ABSTRATOS DE DADOS


Exemplo em Go
package main

import "./bintree"

package bintree func main() {


arvore := bintree.NovaÁrvore(42)
type nó struct { arvore.Insere(11, 43, 13, 7)
valor int arvore.EmOrdem()
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]) }
}
69

TIPOS ABSTRATOS DE DADOS


Exemplo em Go
func em_ordem(x *nó) {
if x.esq != nil { em_ordem(x.esq) }
println(x.valor)
if x.dir != nil { em_ordem(x.dir) }
}
package bintree func insere(x *nó, v int) *nó {
if x == nil { x = NovaÁrvore(v)
type nó struct { } else if v < x.valor { x.esq = insere(x.esq, v)
valor int } else x.dir = insere(x.dir, v)
esq, dir *nó return x
} }

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]) }
}
70

TIPOS ABSTRATOS DE DADOS


Exemplo em Lua

require "bintree"

x = bintree.arvore:nova(42)
x:insere(11, 43, 13, 7)
x:em_ordem()
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


71

TIPOS ABSTRATOS DE DADOS


Exemplo em Lua
local 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) end
end
local function insere(x, v)
if x == nil then x = arvore:nova(v)
module("bintree", package.seeall) elseif v < x.valor then x.esq = insere(x.esq, v)
else x.dir = insere(x.dir, v)
end
arvore = {}
return x
local mt = {__index = arvore}
end

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


72

TIPOS ABSTRATOS DE DADOS

1. Criar uma meta


1. Criar um tipo;
Como definir tabela para o tipo;
2. Definir métodos
um TAD 2. Definir funções
para o tipo.
com prefixo “tipo”.

Encapsulamento Pacotes Módulos

Somente
Não permite ocultar
identificadores
Visibilidade acesso a atributos
exportados são
do tipo
visíveis
73

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.