O documento compara as linguagens Go e Lua, descrevendo seus principais tipos de dados e características de verificação de tipos. Go possui tipos mais rígidos e verificação estática de tipos, enquanto Lua é fracamente tipada e permite maior flexibilidade. Ambas suportam funções de primeira classe e arrays/mapas associativos, porém diferem nos detalhes de implementação desses tipos.

1. 1
COMPARATIVO ENTRE LINGUAGENS
vs.
Alexandre Moreno, Cássio Korogui, Daniel Hey, Guilherme Polo
Julho, 2010

2. 2
HISTÓRICO

3. 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. 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. 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. 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. 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. 8
HISTÓRICO
Tempo de
2 anos 16 anos
vida
Principal Programação
Extensão
uso de sistemas
Concorrente, Funcional,
imperativo, imperativo,
Paradigmas
orientado a orientado a
objetos objetos

9. 8
HISTÓRICO
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

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

11. 9
TIPOS DE DADOS

12. 10
TIPOS DE DADOS
•A linguagem Lua conta com apenas 8 tipos:
• nil, boolean, number, string, userdata, thread, function e table.

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

14. 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;

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

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

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

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

19. 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”

20. 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”

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

22. 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}

23. 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.
em Go utilizam a sintaxe x[inicio:fim], onde x é um
• Slices
array qualquer e ambos os índices são incluídos. Lua não
disponibiliza slices.

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

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

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

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

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

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

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

31. 25
VERIFICAÇÃO DE TIPOS

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

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

34. 28
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO

35. 29
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
Regras de Precedência
* / % << >> & &^ ^
unário
+ - | ^ not # -
!= == < <= > >= * / %
<- + -
&& ..
|| < > <= >= ˜= ==
and
Menor or

36. 29
EXPRESSÕES E INSTRUÇÕES DE ATRIBUIÇÃO
Regras de Precedência
* / % << >> & &^ ^
unário
+ - | ^ not # -
!= == < <= > >= * / %
<- + -
&& ..
|| < > <= >= ˜= ==
and
Menor or

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

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

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

40. 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”

41. 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;

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

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

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

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

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

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

48. 38
ESTRUTURAS DE CONTROLE

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

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

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

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

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

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

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

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

57. 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 )

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

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

60. 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;

61. 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 ;} }

62. 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”.

63. 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;

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

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

66. 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;

67. 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
}

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

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

70. 55
ESTRUTURAS DE CONTROLE
Comandos Protegidos em Go
• Exemplo:
package main
func main() {
canal := make(chan int);
go func() {
for { print(<-canal) }
}();
for {
select {
case canal <- 0:
case canal <- 1:
}
}
}

71. 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
...
}

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

73. 57
MODULARIZAÇÃO

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

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

76. 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, ...).

77. 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()

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

79. 63
POLIMORFISMO

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

81. 65
POLIMORFISMO
• Em Go, interfaces são utilizadas para obter polimorfismo
universal de subtipo.
package main
type StrInterface interface { str() string }
type Rã int
type 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)
}

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

83. 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})

84. 67
TIPOS ABSTRATOS DE DADOS

85. 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]) }
}

86. 69
TIPOS ABSTRATOS DE DADOS
Exemplo em Go
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]) }
}

87. 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]) }
}

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

89. 71
TIPOS ABSTRATOS DE DADOS
Exemplo em Lua
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

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

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

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