Linguagem Go

Paradigmas de Linguagens de

Programação

Delano Oliveira

Janderson Jason

Luan Barbosa

Natã Melo

{delanoho, jandersonjba, luanbg, natavm}@lcc.ufcg.edu.br

Agenda

Introdução

Valores e Tipos

Armazenamento

Associações

Abstrações

Unidades de Programa

Sistemas de Tipos

Sequenciadores

Concorrência

Conclusão

PLP - Linguagem Go2

Introdução

Introdução

Motivação

Sintaxe e Semântica

Processador da Linguagem

Outras Características

PLP - Linguagem Go4

Motivação

Compilada

Sensação de uma linguagem dinâmica

Simula Orientação a Objetos

Possui Garbage Collection

Multi-processamento

Open-source

18a linguagem mais usada no mundo segundo o

site da Tiobe

PLP - Linguagem Go5

Sintaxe e Semântica

Go reúne características sintáticas de várias

linguagens

Possui uma Sintaxe simples e intuitiva

A sintaxe é descrita por uma Gramática

(Extended Backus-Naur Form)

Semântica Operacional

PLP - Linguagem Go6

Processador da Linguagem

PLP - Linguagem Go7

Código Fonte *.8 ou *.6 Executável

Compilador: gccgo

(6g, 6l, 8g, 8l)

Outras Características

Criada pela Google e lançada em novembro de

2009

Equipe: Robert Griesemer, Rob Pike e Ken

Thompson

PLP - Linguagem Go8

Valores & Tipos

Valores & Tipos

Valores

Boolean

Numérico

String

Array

Struct

Ponteiros

Abstração de função e

procedimento

Mapa

Channel

Tipos

Primitivos

Compostos

Recursivo

Checagem de Tipos

Equivalência de Tipos

Princípio da Completude

Expressões

PLP - Linguagem Go10

else if (jogador_atual.GetCor() == Vermelho){

tomadas, tuplas, _ := JogadaObrigatoria(tabuleiro_jogo,

jogador_atual.GetCor());

if (LenArrayNode(tomadas) == 1){

if (!tabuleiro_jogo.IsPecaDama(tuplas[0].X, tuplas[0].Y)) {

contagemEmpate = 0;

}

RealizarTomada(tabuleiro_jogo, tuplas[0].X, tuplas[0].Y,

tomadas[0],

jogador_atual.GetCor(), true);

}

var posicao3 *Coordenada

}

Valores


Em Go, abstrações de funções e procedimentos são valores de segunda

classe.

Funções podem ser passadas como parâmetros e retornadas como valor

de função.

Valores


Em Go, abstrações de funções e procedimentos são valores de segunda

classe.

Funções podem ser passadas como parâmetros e retornadas como valor

de função.

Abstração de FunçãoNúmericos

BooleanosAbstração de Procedimento Ponteiro

Arrays

else if (jogador_atual.GetCor() == Vermelho){

tomadas, tuplas, _ := JogadaObrigatoria(tabuleiro_jogo,

jogador_atual.GetCor());

if (LenArrayNode(tomadas) == 1){

if (!tabuleiro_jogo.IsPecaDama(tuplas[0].X, tuplas[0].Y)) {

contagemEmpate = 0;

}

RealizarTomada(tabuleiro_jogo, tuplas[0].X, tuplas[0].Y,

tomadas[0], jogador_atual.GetCor(), true);

}

var posicao3 *Coordenada

}

Tipos Primitivos


Boolean – Representa o conjunto de valores booleanos

Numeric – Representa o conjunto de valores inteiros ou valores de ponto-

flutuante

uint(8, 16, 32, 64), int(8, 16, 32, 64), float(32, 64), complex(64, 128)

String – Array de bytes. Imutável

var barra string = "===== “

var contagemEmpate int = 0

var travou bool = false

var porcentagem float = 10.5

Tipos Compostos


type Tabuleiro struct {

matriz [8] [8] *Peca

int totalPecas

}

Struct – Sequência de elementos.

Campos: possuem nome e tipo.

Produtos Cartesianos : Structs

Mapeamentos : Arrays, Mapas ou Funções

resultado := map[string]int{"sao paulo" : 3, "corinthians" :0}

Mapa – Grupo não ordenado de elementos. Possui Keys únicas.

Tipos Compostos


Struct – Sequência de elementos.

Campos: possuem nome e tipo.

Produtos Cartesianos : Structs

Mapeamentos : Arrays, Mapas ou Funções

resultado := map[string]int{"sao paulo" : 3, "corinthians" :0}

Mapa – Grupo não ordenado de elementos. Possui Keys únicas.

[][]*Peca x inttype Tabuleiro struct {


int totalPecas

}

type Tabuleiro struct {


int totalPecas

}

Tipos Compostos

Tipos Recursivos: Structs

Go não dá suporte:

União Disjunta

Conjuntos Potência


Implementados através de ponteiros.

type Node struct {

valor Tupla

next *Node

}

Checagem de Tipos

Go é estaticamente e fortemente tipada.


func main (){

var nome string = "plp"

nome = 18

}

prog.go:6: cannot convert 18 to type string

prog.go:6: cannot use 18 (type int) as

type string in assignment

func main (){

dez_decimal := 10.0

var dez int = dez_decimal

}

prog.go:6: cannot use dez_decimal (type

float) as type int in assignment

FortementeErro ao tentar

compilar!!!

Equivalência de Tipos

Go dá suporte a equivalência nominal


package main

type Peca struct {cor int, dama bool}

type Tupla struct {tamanho int,comida bool}

func (peca *Peca) EhDama () (bool){

return peca.dama

}

func main (){

var tupla *Tupla = new(Tupla)

tupla.EhDama()

}

prog.go:15: tupla.EhDama undefined

(type Tupla has no field EhDama)

Erro ao tentar

compilar!!!

Go não dá suporte a equivalência estrutural!

Princípio da Completude

Go quebra o princípio da completude de tipo.

É necessário o uso do tipo File para manipular

arquivos persistentes.

Funções só podem retornar valores primitivos ou

ponteiros.


func (tabuleiro *Tabuleiro) IsZerou (cor int) bool

if (…){

return false

}

return true

}

Expressões

Literais: Valores dos tipos bool, int, uint, float, string

Agregados: array, maps, structs

Funções

Go não dá suporte a:

Expressões Condicionais

Expressões Iterativas


Armazenamento

Armazenamento

Variáveis e Atualização

Arrays

Semântica de Cópia x

Semântica de Referência

Variáveis

Locais e Globais

Heap

Persistentes

Tipos de Comandos

Skip

Atribuição

Chamada de

procedimento

Comandos

Sequencial

Colateral

Condicional

Expressões com Efeitos

Colaterais



Os valores armazenáveis (storables) são os

valores dos tipos primitivos e ponteiros

Variáveis Temporárias

Todas as variáveis, com exceção do tipo File

Variáveis Persistentes

Em Go, as variáveis persistentes são do tipo File



Go dá suporte a atualização seletiva e atualização

total


Seletiva

Total

var posicaoFinal Coordenada;

posicaoFinal.x = 1;

posicaoFinal.y = 2;

var posicaoInicial Coordenada;

posicaoInicial = posicaoFinal;

Arrays


Go dá suporte a Arrays Estáticos. Os arrays possuem tamanho fixo e não podem

armazenar valores de tipos diferentes.

func (tabuleiro *Tabuleiro) GetPecas (cor int) ([12]*Tupla){

var pecas [12] *Tupla;

(...)

return pecas;

}

Semântica de Cópia x

Semântica de Referência


Por Referência

Por Cópia

Semântica de cópia – utilizada para valores de

qualquer tipo.

Semântica de Referência – utilizada apenas para

ponteiros.

var posicao1 Coordenada;

posicao1.x = 1;

posicao1.y = 2;

var posicao2 *Coordenada;

var posicao3 *Coordenada;

posicao2 = &posicao1;

posicao3 = posicao2;

posicao3.x = 5;

posicao3.y = 5;

Variáveis Locais e Globais


Variáveis Globais são declaradas da seguinte

forma: var + nomeVariavel + tipo

Para variáveis locais podem ser utilizados

açúcares sintático

var jogadorDaVez string = “tabuleiro”

func main() {

tamanho := 10;

if (...){

var numBombas = 15;

}

}

Variável Global

Variáveis LocaisAçúcar

Sintático

Variáveis Heap


Variáveis podem ser declaradas a partir da

palavra reservada new.

Não existe um mecanismo para o programador

destruir as variáveis. Go possui Garbage

Collection.

var tabuleiro_jogo *Tabuleiro = new (Tabuleiro)

Alocação de

memória

Variáveis persistentes


oldfile := "text.txt"

newfile := "text2.txt"

doc, _ := ioutil.ReadFile(oldfile)

ioutil.WriteFile(newfile,doc,0644)

São do tipo “File”

for ; pilha != nil ; {

tabTemp := tabuleiro.Copy()

pilha, tuplaAtual = pilha.Pull()

tabTemp.ComerPeca(posX, posY, tuplaAtual, cor)

caminhoAtual, tamanhoCaminhoTupla = TomadaMaximaPeca(tabTemp,

tuplaAtual.FicarX, tuplaAtual.FicarY, cor)

tamanhoCaminhoTupla++

Skip e Atribuição


Não há atribuição múltipla em Go.

Skip e Atribuição


Skip usado para separar expressões

Não há atribuição múltipla em Go.

Atribuição simultâneaAçúcar sintático

for ; pilha != nil ; {

tabTemp := tabuleiro.Copy()

pilha, tuplaAtual = pilha.Pull()

tabTemp.ComerPeca(posX, posY, tuplaAtual, cor)


tuplaAtual.FicarX, tuplaAtual.FicarY, cor)

tamanhoCaminhoTupla++

Atribuição

Chamada de Procedimentos


Chamada de procedimento

Procedimento

peca := new (Peca)

peca.SetCor(Preto)

//...

func (peca *Peca) SetCor (cor int) {

peca.cor = cor

}

Comando Sequencial


meuTabuleiro.n = 0

meuTabuleiro.m = 0

meuTabuleiro.ganhou = false

Comando Colateral Não existem comandos colaterais.

meuTabuleiro.n = 0; meuTabuleiro.m = 0; meuTabuleiro.ganhou = false;

Separados por ponto-e-vírgula,

ou por quebra de linha.

Comando Condicional


Go dá suporte através de: if ,else e switch.

var jogada int;

if (ehHumano) {

var pos [2]int = JogarHumano();

jogada = tabuleiro.Jogada(pos);

} else {

var pos [2]int = JogarAutomatico();

jogada = tabuleiro.Jogada(pos);

}

var aux string;

switch opcao{

case 1: aux = "Jogar“

case 2: aux = "Ajuda"

case 3: aux = "Fechar"

}

Comandos Iterativos


for i > 0 {

var a int = Random(n);

var b int = Random(n);

//...

}

for i:=0; caminhoAtual[i] != nil && i < MAXIMO_CAMINHOS;

i++ {

nodeAtual = new(Node);

nodeAtual.SetValor(tuplaAtual);

//...

}

Iteração definida

Iteração indefinidaPalavra reservada for

funcionando como o comando while em

outras linguagens.

Associações

Associações

Entidades Associáveis

Escopo

Estrutura de Blocos

Visibilidade

Declarações

Definição

Declaração de Tipo

Declaração de Variável

Declarações Colaterais

Declarações Sequenciais

Declarações Recursivas

Comando Bloco

Expressão Bloco

Princípio da Qualificação


Entidades Associáveis


meuTabuleiro.m = 0;

meuTabuleiro.ganhou = false;

var Numero int = calculaNumDeMinas(n);

const( MAX_MOVIMENTOS int = 50);

Valores primitivos e compostos

Abstrações de funções e procedimentos

Variáveis e Tipos

Escopo

Em Go, o corpo de um bloco é avaliado no

ambiente em que foi definido (associação

estática).


const s = 2;

func incremento ( d int ) int {

return d∗s;}

func executaIncremento ( valor int ) int {

const s = 3;

return incremento ( valor );

}

func main () {

fmt.Println( executaIncremento(5) );

}

Saída: 10

Blocos: Estrutura e Visibilidade


var tamanhoTabuleiro int = 10;

for {

var tamanhoTabuleiro = 15;

for {

var tamanhoTabuleiro = 20;

fmt.Println( tamanhoTabuleiro );

break;

}

fmt.Println( tamanhoTabuleiro ) ;

break;

}

fmt.Println( tamanhoTabuleiro );

imprime 20

imprime 15

imprime 10

Estrutura: blocos aninhados.

Visibilidade: variáveis declaradas em blocos

de escopo internos não são visíveis a blocos

de escopo externos.

Definição


const( MAX_MOVIMENTOS int = 50)

func Jogada() (int,int) {

//…

}

var posJogada;

var posX *int;

var posAux *int;

As definições em Go podem ser de tipo, abstração

de funções, abstração de procedimentos, variáveis,

constantes.

Constante

Abstração de função

Variáveis

Declaração de Tipo


type Peca struct {

cor int;

dama bool;

}

Declaração de Variável

var vertical string = "Coordenada Vertical: “;

var valor int = 1;

var decimal float = 1.0;

Go dá suporte a declaração de tipos

através da palavra reservada type.

O tipo Peca sendo declarado.

Como a maioria das linguagens imperativas,

Go dá suporte à declaração sequencial.

Declaração sequencial


tamanhoMaiorCaminho := 0;

tamanhoCaminhoTupla := 0;

var pilha *Node = nil;

var caminhoAtual [MAXIMO_CAMINHOS] *Node;

Declarações Colaterais

Go não dá suporte a este tipo de declaração.

Go dá suporte a declaração recursiva.

Declaração recursiva


func TomadaMaximaPeca(tabuleiro *Tabuleiro, posX int, posY int, cor int)

([MAXIMO_CAMINHOS] *Node, int) {

caminhos := tabuleiro.GetOpcoesComida(posX, posY, cor);

for ;pilha != nil; {


tuplaAtual.FicarX, tuplaAtual.FicarY, cor);

return caminhosMaximos, tamanhoMaiorCaminho;

}

Chamada recursiva

Comando bloco


Go dá suporte a comando bloco.

Declaração que é usada apenas pra executar o comando

func ( pilha ∗Node ) PrintValorProximo( ) {

Println ( "|" , pilha.GetValor( ) , "|" );

next := pilha.GetNext( );

Println(next.GetValor());

}

Expressão bloco

func (peca *Peca) GetValue(peca2 *Peca)(bool){

valor1 := peca.EhDama()

valor2 := peca2.EhDama()

return valor1 && valor2

}


Go dá suporte a expressão bloco.

Declarações usadas apenas para avaliar a expressão.

Princípio da Qualificação

Go não viola o princípio da qualificação, pois é

possível realizar qualquer computação dentro de

um bloco.


func (pilha *Node) GetNext() (*Node, *Tupla){

next := pilha.GetNext()

valor := next.GetValor()

func nome(){

//Corpo da funcao

}

return next, valor

}

Um bloco dentro do outro.

Abstrações

Abstrações

Tipos de Abstrações

Abstração de Função

Abstração de

Procedimento

Princípio da Abstração

Parâmetros

Argumentos

Passagem de Parâmetros

Princípio da

Correspondência

Ordem de Avaliação


Abstração de Função

PLP - Linguagem Go 50

func calculaNumDeMinas(tamanho int) int{

numeroDeBombas := int(tamanho*tamanho*20/100);

if (numeroDeBombas%2 == 0) {

numeroDeBombas += 1;

}

//m sempre impar

if (tamanho <= 10) {

numeroDeBombas += 2;

}

return numeroDeBombas;

}

Go dá suporte a abstrações de funções através da palavra

reservada func.

A presença do retorno caracteriza a abstração de função.

Abstração de Procedimento


func inicializarJogo() {

tabuleiro.ReiniciaTabuleiro();

ehHumano = true;

}

Go usa a mesma palavra reservada para caracterizar uma

Abstração de Procedimento, como em Abstrações de Funções.

(func)

A diferença que caracteriza a Abstração de Procedimento é a

falta do retorno.

Princípio da abstração


Go não viola o princípio da abstração, pois é possível

construir abstração sobre qualquer categoria sintática da

linguagem, como por exemplo: variáveis, funções e

procedimentos.

Parâmetros


type Peca struct {

cor int

dama bool

}

func (peca *Peca) EhDama () (bool){

return peca.dama

}

Como Go é fortemente tipada, os parâmetros devem possuir

tipos definidos.

Podem ser de qualquer tipo.

Passagem de Parâmetros


Em Go a passagem de parâmetros é por cópia\valor.

func Inverter (i int) int {

if(i != 0) {

return 0

}

return 1

}

Go não dá suporte a passagem de parâmetros por referência,

mas simula com o uso de ponteiros.

func (pilha *Node) Pull() (*Node, *Tupla) {

return pilha.GetNext(), pilha.GetValor()

}

Ponteiro

Princípio da Correspondência


Go viola o princípio da correspondência, pois não existe um

mecanismo de passagem de parâmetro correspondente a

definição de constante.

Código abaixo não é compilável.

const constante = 10;

func funcao ( c const ) const {

return c ;

}

func main ( ) {

fmt.Println ("Imprimir constante:" , funcao ( constante ) ) ;

}

Dá erro de sintaxe

Ordem de Avaliação


Eager Evaluation

var p int;

func main () {

p = 3;

print ( p )

}

func print ( n int ) {

Println(n);

p = 100;

Println(n);

}

Saída:

3

3



Pacotes

Tipos Abstratos de Dados

Objetos e Classes

Unidades Genéricas


Pacotes


package tabuleiro

//...

func (meuTabuleiro *Tabuleiro) Ganhou() bool {

return meuTabuleiro.ganhou;

}

func (meuTabuleiro *Tabuleiro) AlguemGanhou(){

meuTabuleiro.ganhou = true;

}

func calculaNumDeMinas(tamanho int) int{

//...

return numeroDeBombas;

}/

Função com

visibilidade privada

Funções visíveis

As funções e variáveis globais que começam com letra

Maiúscula serão visíveis para quem importar esse pacote.

Caso contrário, a função fica com visibilidade privada.

Tipo Abstrato de Dados


package tabuleiro

import (. "fmt"; . "./pecaPkg"; . "./util")

type Tabuleiro struct {matriz [8] [8] *Peca}

func (tabuleiro *Tabuleiro) SetPecaDama (x int, y int){

tabuleiro.matriz[x][y].SetDama(true)

}

//...

Objetos e Classes


type Node struct {

valor Tupla

next *Node

}

//...

func (pilha *Node) Pull() (*Node, *Tupla) {

return pilha.GetNext(), pilha.GetValor()

}

Unidades Genéricas

Go não dá suporte a unidades genéricas.

Go não tem Objetos e Classes, porém, simula-os através de

structs e funções ligadas a esses tipos.

Sistemas de Tipos

Sistema de Tipos

Monomorfismo

Sobrecarga

Polimorfismo Paramétrico

Polimorfismo por Inclusão

Interfaces

Coerção


func (meuTabuleiro *Tabuleiro) Ganhou() bool{

return meuTabuleiro.ganhou;

}

func (meuTabuleiro *Tabuleiro) AlguemGanhou() {

meuTabuleiro.ganhou = true;

}

Println("---------------------------");

Print("Linha: ");

Println(posMaquina[0]+1);

Print("Coluna: ");

Println(posMaquina[1]+1);

Println("---------------------------");

Monomorfismo


As abstrações definidas pelo

programador, em Go, são

monomórficas. Toda

entidade tem um tipo

específico associado.

Mas, algumas abstrações

embutidas (built-in) não

são monomórficas.

Sobrecarga


var barra string = "===== “;

//...

if (tabuleiro_jogo.IsZerou (jogador1.GetCor())){

Println(barra + "Jogador", jogador2.GetCor() + 1, "VENCEU! PARABÉNS", barra);

break;

}//...

Para tipos da própria linguagem, um único

identificador ou operador pode denotar

diferentes abstrações.

Go dá suporte a sobrecarga de operadores built-in.

Entretanto, não dá suporte a sobrecarga de operaçoes.

(Operadores: +, -, e outros)

Polimorfismo por Inclusão


type Natural int;

type Inteiro int;

var x Natural = 1;

var y Inteiro = -1;

Println(x+y);

//input.go:10: invalid operation: x + y (type Natural + Inteiro)

Go não tem tipos que contenham

subtipos que herdam operações

aplicáveis a valores desses tipos.

Polimorfismo Paramétrico


func polimorfismoParametrico(a int64, b int64) {

Println(a);

Println(b);

}

func main() {

var x int8 = 1;

var y int8 = 2;

polimorfismoParametrico(x, y);

}

//input.go:13: cannot use x (type int8) as type int64 in function argument

//input.go:13: cannot use y (type int8) as type int64 in function argument

Go não dá suporte a polimorfismo paramétrico.

Interface


package main

import . "fmt";

func main(){

jogador := new(Jogador);

jogador.nome = "iza";

peca := new(Peca);

peca.cor = "preto";

imprimir(jogador);

imprimir(peca);

}

type printer interface { Print(); }

func (p *Peca) Print() { Println(p.cor); }

func (j *Jogador) Print() { Println(j.nome); }

func imprimir (p printer) { p.Print(); }

type Peca struct { cor string; }

type Jogador struct { nome string; }

Go simula

o uso de

interface

com o tipo

“interface”.

Coersão


func Random(n int) int {

sec, nsec, err := Time();

if err != nil {

Seed(int64(n));

} else {

Seed(int64(n)+(sec*1e9+nsec));

}

return int(Int63n(int64(n)))

}

Não há mapeamento implícito de

valores de um tipo para valores de um

outro tipo.

Em substituição às coerções,

são adotados casts.

Sequenciadores

Sequenciadores

Desvios Incondicionais

Escapes

Exceções


Desvios Incondicionais


I: Println(“Digite a dimensao: (N)");

var tam int = ReadInt();

if ( tam < 20 && tam > 4) {

goto L;

}

Println(“N fora do limite [4,20].");

goto I;

L: geraTabuleiro(tam);

Para fazer Desvios Incondicionais usamos a palavra reservada “goto”

Só podemos fazer desvios incondicionais dentro do escopo da

abstração de função. (Não podemos ir para pontos mais externos do

programa).

Escape


for i := 0; i < len(tabuleiro); i++ {

for j := 0; j < len(tabuleiro[i]); j++ {

if (tabuleiro[i][j] == 9) {

Println("Achou bomba na linha ", i+1);

break;

}

}

}

Iteração afetada

pelo escape

Go dá suporte a escape através da palavra

reservada“break” e “continue”.

Escape não rotulado apenas finaliza a iteração

corrente.

Escape rotulado


busca:

for i := 0; i < len(tabuleiro); i++ {

for j := 0; j < len(tabuleiro[i]); j++ {

if (tabuleiro[i][j] == 9) {

Println("Achou bomba na linha ", i+1);

break busca;

}

}

}

Go dá suporte a escape rotulado através da

palavra reservada break mais o rótulo.

Rótulo

Exceções


Go não dá suporte a exceções.

Concorrência

Concorrência


var canal = make(chan int);

func main() {

go rotina1();

go rotina2();

}

func rotina1(){

var i int = 0;

for i = 0; i <= 100; i++ {

canal <- i;

}

}

func rotina2(){

for {

msg := <- canal;

Println(msg);

if(msg == 100){

break;

}

}

}

Go dá suporte a concorrência

através de goroutines.

A comunicação entre os

processos concorrentes é

através de channel.

Goroutines

Channel

Spin-Lock


func acquire(){

for(usandoRecurso){

}

usandoRecurso = true;

}

func relinquish(){

usandoRecurso = false;

}

func rotina1(){

acquire();

//regiao critica

relinquish();

}

func rotina2(){

acquire();

//regiao critica

relinquish();

}

Flag

Rotinas

O flag é uma variável global.

Assim permitimos que apenas uma

rotina tenha acesso ao recurso.

Conclusão



Referências

Referências


http://alovasconcelos.net/

http://golang.org

http://tutorial.danielmazza.info/go

RAMALHO, Franklin. Notas de Aula da disciplina Paradigmas de

Linguagens de Programação, 2010.

http://forum.zwame.pt/showthread.php?t=348920

Technology

Linguagem Go