comparativo entre go e lua

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



• 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



• 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

http://mitpress.mit.edu/sicp/

http://mitpress.mit.edu/sicp/

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


• 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


• 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


* / % << >> & &^ ^+ - | ^ 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


• 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


• 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


• 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


• 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


• 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


• 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


• 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

http://tinyurl.com/2fptp66

http://tinyurl.com/2fptp66

ESTRUTURAS DE CONTROLE

38


• 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


• 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


• 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


• 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


• 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




• Expressões de uma cláusula não precisam ser constantes; são avaliadas da esquerda para direita e de cima para baixo.


44




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


45


• Sintaxe geral de switch de tipos:

• switch [simplestmt ;] typeSwitchGuard {{typeSwitchCase : {stmt ;}}}


case type {, type} default

[ident :=] primaryExp . ( type )

46


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


47


• 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


• 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


• 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


• 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


• 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


• 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


• 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


• 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


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


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


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


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


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

http://golang.org/doc/go_spec.html

http://golang.org/doc/go_spec.html

http://golang.org/doc/go_lang_faq.html

http://golang.org/doc/go_lang_faq.html

comparativo entre go e lua

Documents