sudo apt-get install build-essential autogen automake autoconf g++ vim libxext-dev

Este comando instala as bibliotecas básicas para desenvolvimento em C e em C++, além da versão improved do editor de textos VI.

Depois de concluída a instalação, você pode fazer um teste digitando o programa alomundo.c:

;

/* Alo mundo */
#include <stdio.h>
int main (int argc, char * argv[])
{
printf(“Alô, mundo!\n”);
return 0;
}

Para compilar, execute

c++ alomundo.cpp -o alomundo

Quando meu site foi hackeado a vontade de desistir foi grande, mas a leitura de alguns comentários me incentivaram. Muito obrigado. Vou tentar não decepciona-los.

Grande abraço.

Este documento explica como escrever uma nova package e como testar o código. Ele assume que você tenha instalado Go, usando as instruções de instalação.
N.T. – Aqui mesmo neste blog, disponibilizei a tradução do tutorial de instalação.

Antes de embarcar em uma mudança de uma package existente ou na criação de uma nova package, é uma boa idéia enviar uma mensagem à lista de correspondência para que as pessoas saibam o que você pretende fazer. Agindo assim você ajuda a evitar duplicação de esforços e habilitar discussões sobre design antes que haja muito código escrito.

Recursos da comunidade

Para ajuda em tempo real, podem haver usuários ou desenvolvedores em #go-nuts no servidor Freenode IRC. A lista oficial para discussão da linguagem Go é Go Nuts.

Bugs podem ser relatados usando o Go issue tracker”.

Para aqueles que desejem acompanhar o desenvolvimento, existe outra lista, golang-checkins, que recebe uma mensagem resumindo cada checkin feito no repositório Go.

Criando uma nova package

O código-fonte para a package com caminho import x/y é, por convenção, mantida no diretório $GOROOT/src/pkg/y/y.

Makefile

Seria bom ter ferramentas específicas Go que verificassem os arquivos-fonte para determinar o que montar e em que ordem, mas por enquanto, Go usa a ferramenta GNU make. Portanto, o primeiro arquivo a criar em uma diretório de uma nova package é geralmente
o Makefile. A forma básica usada na árvore de fontes de Go é ilustrada por src/pkg/container/vector/Makefile:

include ../../../Make.$(GOARCH)

TARG=container/vector
GOFILES=\
	intvector.go\
	stringvector.go\
	vector.go\

include ../../../Make.pkg

Fora da árvore de fontes de Go (para packages pessoais), a forma padrão é

include $(GOROOT)/src/Make.$(GOARCH)

TARG=mypackage
GOFILES=\
	my1.go\
	my2.go\

include $(GOROOT)/src/Make.pkg

A primeira e a última linha incluem definições padrão e regras. Packages mantidas na árvore padrão Go usam um caminho relativo (ao invés de $(GOROOT)/src) de modo que make trabalhará corretamente mesmo se $(GOROOT) contiver espaços. Isto torna fácil aos programadores experimentar Go.
TARG é o caminho alvo de instalação para a package, a string que clientes usarão para importa-la. Dentro da árvore Go, a string deve ser a igual ao diretório no qual o Makefile aparece, como o prefixo $GOROOT/src/pkg removido. Fora da árvore Go, você pode usar qualquer TARG que deseje desde que não conflite com o nome de packages padrão Go.
Uma convenção comum é usar um nome identificador de primeiro nível para agrupar suas packages: myname/tree, myname/filter, etc. Observe que mesmo que você mantenha suas packages fora da árvore Go, a execução de “make install” instalará os binários de sua package no local padrão – $GOROOT/pkg – para facilitar a sua localização.

GOFILES é uma lista de arquivos-fonte a serem compilados para criar a package. O caracter \ no final de cada linha permite quebras a lista em linhas múltiplas para faciliar
a ordenação.
Se você criar um diretório de uma nova package na árvore Go, adicione-o a lista em $GOROOT/src/pkg/Makefile de modo que ele seja incluido na montagem padrão. Então execute:

cd $GOROOT/src/pkg
./deps.bash

para atualizar o arquivo de dependências – Make.deps (Isto acontece automaticamente cada vez que você executa all.bash ou make.bash).

Se você altera os imports de uma package existente, não precisa editar $GOROOT/src/pkg/Makefile mas ainda precisará executar deps.bash como acima.

Arquivos-fonte Go

A primeira declaração em cada arquivo-fonte listado no Makefile deve ser o nome da package, onde “nome” é o nome padrão da package para “imports” (Todos os arquivos em uma package devem usar o mesmo nome). A convenção de Go é que o nome da package seja o último elemento do caminho do import: a package importada “crypto/rot13″ deve ser nomeada rot13. No momento, as ferramentas Go impõem uma restrição que nomes de packages sejam únicos em todas as packages relacionadas a um único binário, mas esta restrição será abolida em breve.

Go compila todos os arquivos-fonte em uma package de uma vez, então um arquivo pode fazer referência a constantes, variáveis, tipos e funções em outro arquivo sem arranjos especiais ou declarações.

Escrever código Go limpo e idiomático está além do escopo deste documento. O documento Effective Go é uma introdução a este tópico.

Testando

Go tem um framework de teste peso-leve conhecido como gotest. Você escreve um teste criando um arquivo com o nome terminado em _test.go que contém funções nomeadas TestXXX com a assinatura func(t *testing.T). O framework de teste executa cada uma destas funções; se a função chama uma função de falha como t.Error ou f.Fail, o teste é considerado como tendo falhado.
A documentação do comando gotest e a documentação da package testing dão mais detalhes.

Os arquivos *_test.go não devem estar listados no Makefile.

Para executar o teste, execute make test ou gotest (são equivalentes). Para executar apenas os testes em um único arquivo de teste, por exemplo one_test.go, execute gotest one_test.go.

Se sua mudança afeta performance, adicione uma função Benchmark (veja a documentação do comando gotest) e execute-a usando gotest -benchmarks=..

Uma vez que seu novo código esteja testado e funcionando, é hora de revisa-lo e submete-lo.

[Voltar ao menu]

Multiplexação

Com channels, é possível servir múltiplos clientes goroutines independentes sem escrever
um multiplexador explícito. O truque é enviar ao servidor um channel na mensagem,
o quel será então usado para responder ao sender original.

Um programa cliente-servidor real tem muito código, então aqui está um substituto bastante
simples para ilustrar a idéia. Ele começa definindo um tipo “request”, que embute um channel
que será usado para responder.

    type request struct {
        a, b    int;
        replyc  chan int;
    }

O servidor será trivial: ele fará operações simples com inteiros. Aqui está o código
que invoca a operação e responde à requisição:

    type binOp func(a, b int) int

    func run(op binOp, req *request) {
        reply := op(req.a, req.b);
        req.replyc <- reply;
    }

A linha 18 define o nome "binOp" para a função recebendo dois inteiros e
retornando um terceiro.

A rotina "server" executa um loop infinito, recebendo requisições e, para prevenir
bloqueio devido a operações muito demoradas, "starta" uma goroutine para fazer o trabalho de verdade.

    func server(op binOp, service chan *request) {
        for {
            req := <-service;
            go run(op, req);  // Não espera
        }
    }

Construimos um servidor de uma forma familiar, "startando-o" e retornando um channel
conectado a ele:

    func startServer(op binOp) chan *request {
        req := make(chan *request);
        go server(op, req);
        return req;
    }

Aqui está um teste simples. Ele "starta" um servidor com um operador de adição e
envia N requisições sem esperar por suas respostas. Apenas depois de que todas as
requisições enviadas sejam executadas, checa seus resultados.

    func main() {
        adder := startServer(func(a, b int) int { return a + b });
        const N = 100;
        var reqs [N]request;
        for i := 0; i < N; i++ {
            req := &reqs[i];
            req.a = i;
            req.b = i + N;
            req.replyc = make(chan int);
            adder <- req;
        }
        for i := N-1; i >= 0; i-- {   // Não importa a ordem
            if <-reqs[i].replyc != N + 2*i {
                fmt.Println("fail at", i);
            }
        }
        fmt.Println("done");
    }

Um contra-tempo com este programa é que ele não desliga o servidor de forma limpa; quando "main" retorna
existe um número de goroutines prolongadas bloqueadas na comunicação. Para resolver isto, podemos
prover um segundo channel "quit" para o servidor:

    func startServer(op binOp) (service chan *request, quit chan bool) {
        service = make(chan *request);
        quit = make(chan bool);
        go server(op, service, quit);
        return service, quit;
    }

Ele passa o channel quit para a função "server", que o utiliza desta forma:

    func server(op binOp, service chan *request, quit chan bool) {
        for {
            select {
            case req := <-service:
                go run(op, req);  // Não espera
            case <-quit:
                return;
            }
        }
    }

Dentro da função "server", a declaração "select" escolhe qual das múltiplas comunicações
listadas pelos seus "cases" pode continuar. Se todos estiverem bloqueados, aguarda até que um
possa continuar; se vários puderem prosseguir, escolhe um aleatoriamente. Neste exemplo, o
"select" permite ao servidor reconhecer requisições até que receba a mensagem "quit", no ponto
em que retorna, terminando sua execução.

Tudo que resta é focalizar o channel "quit" no fim de main:

        adder, quit := startServer(func(a, b int) int { return a + b });

        quit <- true;

Existe muito mais sobre programação Go e programação concorrente em geral, mas este "quick tour"
deve lhe oferecer alguns dos princípios básicos.

Bom, esta foi a última parte da minha tradução do Tutorial disponibilizado pela equipe do Go.
Meu inglês anda meio enferrujado, então se alguém puder contribuir sugerindo alterações
no texto, agradeço.

Um forte abraço a todos.

\\//

yIn nI' yISIQ 'ej yIchep

André Luiz de Oliveira Vasconcelos

[Voltar ao menu]

Agora chegamos aos processos de comunicação e programação concorrente. É um assunto vasto, então para ser breve, assumimos alguma familiaridade com o tópico.

Um programa clássico neste estilo é a peneira de números primos. (A peneira de Eratosthenes (The sieve of Eratosthenes) é mais eficiente do que o algoritmo aqui apresentado, mas estamos mais interessados em concorrência do que em algoritmos no momento). Ela (a peneira) funciona pegando uma cadeia de todos os números naturais e introduzindo uma sequência de filtros, uma para cada número primo, para destacar os múltiplos daquele número primo. A cada passo temos uma sequência de filtros dos primos até então, e o próximo número a ser retirado é o próximo primo, o qual dispara a criação do próximo filtro na cadeia.

Aqui está um diagrama de fluxo; cada caixa representa um elemento filtro cuja criação é disparada pelo primeiro número que fluiu dos elementos anteriores.

Para criar uma cadeia de inteiros, usamos um channel Go, o qual, emprestado dos descendentes de CSP, representa um canal de comunicação que pode conectar duas computações concorrentes. Em Go, variáveis channel são referências a um objeto de tempo de execução que coordena a comunicação; como feito com maps e slices, use make para criar um novo channel.

Aqui está a primeira função em progs/sieve.go:

    // Envia a sequência 2, 3, 4, ... para o channel ch
    func generate(ch chan int) {
        for i := 2; ; i++ {
            ch <- i  // Envia 'i' para o channel 'ch'
        }
    }

A função generate envia a sequência 2, 3, 4, 5, … para seu argumento channer, ch, usando o operador binário de comunicações <-. Operações com channel, bloqueiam, então se não existir um receptor para o valor em ch, a operação esperará até que um (receptor) se torne disponível.

A função filtro tem três argumentos: um channel de entrada, um channel de saída e um número primo. Ela copia valores da entrada para a saída, descartando qualquer coisa divisível pelo número primo. O operador unário de comunicação <- (recebe) recupera o próximo valor no channel.

    // Copia os valores do channel in para o channel out,
    // removendo aqueles divisíveis por prime
    func filter(in, out chan int, prime int) {
        for {
            i := <-in;  // Receive value of new variable 'i' from 'in'.
            if i % prime != 0 {
                out <- i  // Send 'i' to channel 'out'.
            }
        }
    }

O gerador (método generate) e os filtros (método filter) executam concomitantemente. Go tem seu próprio modelo de processos/coroutines, para evitar confusões de notação chamamos processamento concomitante em Go de goroutines. Para “startar” uma goroutine, chame a função precedendo a chamada com a palavra-chave go; Isto inicia a função executando em paralelo com o processo corrente mas no mesmo espaço de endereçamento:

    go sum(hugeArray); // calcula a soma em background

Se você quer saber quando o cálculo está pronto, passe um channel o qual pode ser verificado:

    ch := make(chan int);
    go sum(hugeArray, ch);
    // ... faça alguma coisa enquanto isso
    result := <-ch;  // espera por e recupera o resultado

Voltemos à nossa peneira de números primos. Aqui está a forma como a canalização da peneira é costurada:

    func main() {
        ch := make(chan int);  // Cria um novo channel.
        go generate(ch);  // Starta generate() como uma goroutine.
        for {
            prime := <-ch;
            fmt.Println(prime);
            ch1 := make(chan int);
            go filter(ch, ch1, prime);
            ch = ch1
        }
    }

A linha 29 cria o channel inicial e passa ao método generate, o qual então inicia. Como cada número primo sai do channel, um novo filtro é adicionado ao canal e sua saída torna-se um novo valor de ch.

O programa da peneira pode ser forçado a usar um padrão comum em seu estilo de programação. Aqui está uma variante do método generate, retirado de progs/sieve.go:

    func generate() chan int {
        ch := make(chan int);
        go func(){
            for i := 2; ; i++ {
                ch <- i
            }
        }();
        return ch;
    }

Esta versão faz toda a configuração inicial internamente. Ela cria o channel de saída, lança a goroutine executando uma função literal, e retorna o channel ao chamador. Ela é um “factory” para execuçaõ concomitante, “startando” a goroutine e retornando sua conexão.

A notação de função literal (linhas 12 a 16) permitem-nos construir uma função anônima e chamá-la no mesmo momento. Observe que a variável local ch está disponível para a função literal e existe até mesmo após o retorno do método generate.

A mesma alteração pode ser feita no método filter:

    func filter(in chan int, prime int) chan int {
        out := make(chan int);
        go func() {
            for {
                if i := <-in; i % prime != 0 {
                    out <- i
                }
            }
        }();
        return out;
    }

O loop principal da função sieve torna-se mais simples e clara como resultado, e enquanto estamos nela, vamos transformá-la em um “factory” também:

    func sieve() chan int {
        out := make(chan int);
        go func() {
            ch := generate();
            for {
                prime := <-ch;
                out <- prime;
                ch = filter(ch, prime);
            }
        }();
        return out;
    }

Agora a interface principal para a peneira de números primos é um channel de números primos:

    func main() {
        primes := sieve();
        for {
            fmt.Println(<-primes);
        }
    }

Continua…

Abraços

[Voltar ao menu]

Interfaces provêm uma forma simples de polimorfismo. Elas separam completamente
a definição do que um objeto faz de como ele o faz, permitindo implementações
distintas serem representadas em tempos diferentes pela mesma variável interface.

Como um exemplo, considere este exemplo simples de algoritmo de ordenação, tomado
do arquivo progs/sort.go:

    func Sort(data Interface) {
        for i := 1; i < data.Len(); i++ {
            for j := i; j > 0 && data.Less(j, j-1); j-- {
                data.Swap(j, j-1);
            }
        }
    }

O código precisa apenas de três métodos, os quais empacotamos na interface de ordenação:

    type Interface interface {
        Len() int;
        Less(i, j int) bool;
        Swap(i, j int);
    }

Podemos aplicar Sort a qualquer tipo que implemente Len, Less e Swap. A package sort inclui os métodos necessários para permitir ordenação de arrays de inteiros, strings, etc.; aqui está o código para arrays de int:

    type IntArray []int

 func (p IntArray) Len() int { return len(p); }
 func (p IntArray) Less(i, j int) bool { return p[i] < p[j]; }
 func (p IntArray) Swap(i, j int) { p[i], p[j] = p[j], p[i]; }

Aqui vemos métodos definidos para tipos que não sejam structs. Você pode definir métodos para qualquer tipo que defina e nomeie em sua package.

E agora uma rotina para testar, de progs/sortmain.go. Esta rotina utiliza uma função na package sort, omitida aqui em favor da brevidade, para testar se o resultado está ordenado.

    func ints() {
        data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586};
        a := sort.IntArray(data);
        sort.Sort(a);
        if !sort.IsSorted(a) {
            panic()
        }
    }

Se temos um novo tipo, o qual desejamos que seja capaz de ser ordenado, tudo do que precisamos é fazê-lo implementar os três métodos para aquele tipo, dessa forma:

    type day struct {
        num        int;
        shortName  string;
        longName   string;
    }

 type dayArray struct { 37 data []*day; 38 }

 func (p *dayArray) Len() int { return len(p.data); }
 func (p *dayArray) Less(i, j int) bool { return p.data[i].num < p.data[j].num; }
 func (p *dayArray) Swap(i, j int) { p.data[i], p.data[j] = p.data[j], p.data[i]; }

Impressão

[Voltar ao menu]

Os exemplos de impressão formatada vistos até então foram bem modestos. Nesta seção
falaremos sobre como formatação de I/O (entrada e saída) pode ser bem implementada em
Go.

Vimos simples usos da package fmt, que implementa Printf, Fprintf, e assim por diante.
Dentro da package fmt, Printf é declarado com a seguinte assinatura:

	Printf(format string, v ...) (n int, errno os.Error)

Aquelas reticências (...) representam uma lista variável de argumentos, que em C podem ser manipulados usando-se as macros de stdarg.h, mas em Go é passada usando uma variável de interface vazia (interface {}) e então desempacotada usando a biblioteca de reflexão. É off-topic (fora do assunto), mas o uso de reflexão ajuda a explicar algumas das belas propriedades do métodos Printf de Go, devido à habilidade do Printf de descobrir o tipo de seus argumentos dinamicamente.

Por exemplo, em C cada formato deve corresponder ao tipo de seu argumento. É mais fácil em muitos casos em Go. Ao invés de "%llud" você pode dizer simplesmente "%d"; Printf "sabe" o tamanho e sinal do inteiro e pode fazer a coisa certa pra você. O trecho de código

        var u64 uint64 = 1<<64-1;
        fmt.Printf("%d %d\n", u64, int64(u64));

imprime

	18446744073709551615 -1

De fato, se você for preguiçoso, o formato "%w" imprimirá, em um estilo simples e apropriado, qualquer valor, mesmo um array ou estrutura. A saída de

        type T struct { a int; b string };
        t := T{77, "Sunset Strip"};
        a := []int{1, 2, 3, 4};
        fmt.Printf("%v %v %v\n", u64, t, a);

é

 18446744073709551615 {77 Sunset Strip} [1 2 3 4]

Você pode descartar toda a formatação se usar Print ou Println ao invés de Printf, Estas rotinas implementam formatação completamente automática. A função Print apenas imprime seus elemetos usando o equivalente de "%v"
enquanto Println insere espaços entre argumentos e adiciona uma quebra de linha. A saída de cada uma destas duas linhas é idêntica, àquela da chamada a Printf feita acima.

        fmt.Print(u64, " ", t, " ", a, "\n");
        fmt.Println(u64, t, a);

Se você tem seu próprio tipo que gostaria que fosse formatado por Printf ou Print, apenas lhe dê um método String() que retorne uma string. As rotinas de impressão, examinarão o valor para verificar o mesmo implementa o método (String) e caso o faça, irá utiliza-lo em lugar de outra formatação. Aqui está um exemplo simples.

    type testType struct { a int; b string }

 func (t *testType) String() string {
 return fmt.Sprint(t.a) + " " + t.b
 }

 func main() {
 t := &testType{77, "Sunset Strip"};
 fmt.Println(t)
 }

Uma vez que testType tem um método String, o formatador default para o tipo o utilizará para produzir a saída

    77 Sunset Strip

Observe que o método String chama Sprint (a variante óbvia de Go que retorna uma string) para poceder sua formatação; formatadores especiais podem usar a biblioteca fmt recursivamente.

Outro recurso de Printf é que o formato "%T" imprimirá a representação em string do tipo de um valor, que pode ser prático quando depurando código polimórfico.

É possível escrever formatos de impressão completamente customizados com flags e precisões e etc, mas isto foge um pouco do escopo, então deixaremos como um exercício de exploração.

Você pode perguntar, contudo, como Printf pode prever se um tipo implementa o método String. Na verdade o que ele faz é perguntar "se" o valor pode ser convertido para uma variável interface
que implementa o método.
Esquematicamente, dado um valor v, ele faz isto:

	type Stringer interface {
		String() string
	}

	s, ok := v.(Stringer);  // Test whether v implements "String()"
	if ok {
		result = s.String()
	} else {
		result = defaultOutput(v)
	}

O código usa um type assertion ("v.(Stringer)") para testar se o valor armazenado em v satisfaz a interface Stringer; se satisfaz, s se tornará uma variável de interface implementando o método e ok será verdadeiro. Nós usamos então a variável de interface para chamar o método. (O padrão ",ok" é a forma Go de testar o sucesso de operações como uma conversão de tipo, atualização de map, comunicações e assim por diante, apesar
disso, esta é a única vez em que aparece neste tutorial).
Se o valor não satisfaz à interface, "ok" será falso (false).

N.T. Mais informações sobre type assertion em Go para Programadores C++ - parte 2

Neste trecho de código o nome "Stringer" segue a convenção de adicionar "[e]r" às interfaces descrevendo simples conjuntos de métodos como este.
Um último detalhe. Para completar a coleção, além de Printf etc. e Sprintf etc., existe também Fprintf etc. Diferente de C, o primeiro argumento de FPrintf não é um arquivo. Ao invés disse, é uma variável do tipo io.Write, que é um tipo interface definido na biblioteca io:

	type Writer interface {
		Write(p []byte) (n int, err os.Error);
	}

(Esta interface é outro nome convencional, desta vez para Write; Existe também io.Reader, io.ReadWriter e assim por diante). Deste modo você pode chamar Fprintf para qualquer tipo que implemente um método Write() padrão,
não apenas para arquivos, mas também rede, channels, buffers, o que quer que você deseje.

Continua...

Abraços

[Voltar ao menu]

N.T. – O título original é um tipo de trocadilho com o nome do comando “cat” do Unix. A propósito, cat – o comando – vem de concatenate (concatenar). Além disso, será implementado aqui uma versão de cat que utiliza um algoritmo de criptografia chamado rot13.

Escrita na package file, aqui está uma versão simples do utilitário cat:

    package main

    import (
           "./file";
           "flag";
           "fmt";
           "os";
    ) 

    func cat(f *file.File) {
        const NBUF = 512;
        var buf [NBUF]byte;
        for {
            switch nr, er := f.Read(&buf); true {
            case nr < 0:
                fmt.Fprintf(os.Stderr, "cat: error reading from %s: %s\n", f.String(), er.String());
                os.Exit(1);
            case nr == 0:  // EOF
                return;
            case nr > 0:
                if nw, ew := file.Stdout.Write(buf[0:nr]); nw != nr {
                    fmt.Fprintf(os.Stderr, "cat: error writing from %s: %s\n", f.String(), ew.String());
                }
            }
        }
    }

    func main() {
        flag.Parse();   // Scans the arg list and sets up flags
        if flag.NArg() == 0 {
            cat(file.Stdin);
        }
        for i := 0; i < flag.NArg(); i++ {
            f, err := file.Open(flag.Arg(i), 0, 0);
            if f == nil {
                fmt.Fprintf(os.Stderr, "cat: can't open %s: error %s\n", flag.Arg(i), err);
                os.Exit(1);
            }
            cat(f);
            f.Close();
        }
    }

Por enquanto isto deve ser fácil de acompanhar, mas a declaração switch apresenta alguns novos recursos. Como um loop for, um if ou switch pode incluir uma declaração de inicialização. O switch na linha 18 usa uma (declaração) para criar as variáveis nr e er para armazenar o valor de retorno de f.Read(). (O if na linha 25 segue a mesma idéia). A declaração switch é geral: ela avalia os cases do cima para baixo, procurando pelo primeiro case que case (misericória!) com o valor; as expressões case não precisam ser constantes ou mesmo inteiros, desde que todos tenham o mesmo tipo.
Quando o valor do switch for verdadeiro, podemos deixá-lo vazio - como é também a situação em uma declaração for, um valor não informado significa true. De fato, o switch é uma forma de cadeia de if-else. Neste ponto, deve ser mencionado que em declarações switch cada case tem um break implícito.

A linha 25 chama Write(), fatiando (em Slices) o buffer de entrada, que é ele mesmo um Slice. Slices proporcionam a forma padão de manipular buffers de entrada e saída em Go.

Agora façamos uma variação de cat que opcionalmente criptografa sua entrada usando o algoritmo rot13. É fácil de fazer, simplesmente processando os bytes, mas ao invés disso exploraremos a noção de interface de Go.
A subrotina cat utiliza apenas dois métodos de f: Read() e String(), então comecemos definindo uma interface que em exatamente estes dois métodos. Aqui está o código do programa cat_rot13.go:

    type reader interface {
        Read(b []byte) (ret int, err os.Error);
        String() string;
    }

Qualquer tipo que tenha os dois métodos de reader - indiferente de quaisquer outros métodos que o tipo possa ter - implementa a interface. Uma vez que file.File implementa estes métodos, implementa a interface reader. Podemos forçar a sobrotina cat a aceitar um reader ao invés de um *file.File e funcionaria bem, mas vamos enfeitar um pouco, primeiro escrevendo um segundo tipo que implementa reader, um que encapsula um reader existente e criptografa os dados com rot13. Para fazer isto, nós apenas definimos o tipo e implementamos os métodos sem muito código adicional, temos uma segunda implementação da interface reader.

    type rotate13 struct {
        source    reader;
    }

 func newRotate13(source reader) *rotate13 {
     return &rotate13{source}
 }

 func (r13 *rotate13) Read(b []byte) (ret int, err os.Error) {
     r, e := r13.source.Read(b);
     for i := 0; i < r; i++ {
         b[i] = rot13(b[i])
     }
     return r, e
 }

 func (r13 *rotate13) String() string {
     return r13.source.String()
 }
 // fim de rot

(A função rot13, chamada na linha 42 é trivial e não vale a pena reproduzi-la aqui.)

Para usar o novo recurso, definimos um flag:

    var rot13Flag = flag.Bool("rot13", false, "rot13 the input")

e a usamos de dentro de uma quase inalterada função cat():

    func cat(r reader) {
        const NBUF = 512;
        var buf [NBUF]byte;

        if *rot13Flag {
             r = newRotate13(r)
        }
        for {
             switch nr, er := r.Read(&buf); {
             case nr < 0:
                 fmt.Fprintf(os.Stderr, "cat: error reading from %s: %s\n", r.String(), er.String());
                 os.Exit(1);
             case nr == 0: // EOF
                 return;
             case nr > 0:
                 nw, ew := file.Stdout.Write(buf[0:nr]);
                 if nw != nr {
                      fmt.Fprintf(os.Stderr, "cat: error writing from %s: %s\n", r.String(), ew.String());
                 }
             }
       }
 }

(Podemos também empacotar em main e deixar cat() sozinho, exceto pela alteração do tipo de argumento; considere isto como um exercício.) As linhas de 56 até a 58 definem tudo; se o flag rot13 for verdadeiro (true), empacota o reader que recebemos dentro de um rotate13 e prossegue. Observe que as variáveis da interface são valores, não ponteiros: o argumento é do tipo reader, não *reader, embora por trás ele contenha um ponteiro para um struct.

Aqui está ele em ação:

    % echo abcdefghijklmnopqrstuvwxyz | ./cat
    abcdefghijklmnopqrstuvwxyz
    % echo abcdefghijklmnopqrstuvwxyz | ./cat --rot13
    nopqrstuvwxyzabcdefghijklm
    %

Fãs de dependency injection podem animar-se com quão facilmente interfaces nos permitem substituir a implementação de um descritor de arquivo.

Interfaces são um recurso distinto de Go. Uma interface é implementada por um tipo se o tipo implementa todos os métodos declarados na interface. Isto significa que um tipo pode implementar um número arbitrário de diferentes interfaces. Não existe hierarquia de tipo; as coisas podem ser mais ad hoc, como vimos com rot13. O tipo file.File implementa reader; ele pode também implementar um writer, ou qualquer outra interface construída a partir de seus métodos que se encaixem na situação atual.
Considere a interface Empty:

type Empty interface {}

Todo tipo implementa a interface Empty, o que a faz útil para coisas como containers.

Continua...

Abraço

[Voltar ao menu]

A seguir veremos uma simples package para executar entrada e saída para arquivos com o tipo usual de interface de abertura/fechamento/leitura/gravação. Aqui está o começo do arquivo file.go:

    package file

    import (
        "os";
        "syscall";
    )

    type File struct {
        fd      int;    // número do descritor de arquivo
        name    string; // nome do arquivo na abertura (Open)
    }

As primeiras linhas declaram o nome da package – file – e então importa duas packages. A package os oculta as diferenças entre vários sistemas operacionais para dar uma visão consistente da arquivos e assim por diante; aqui usaremos seus utilitários (da package os) de manipulação de erros e reproduzir os rudimentos de sua entrada e saída para arquivos.

O outro item é a package externa e de baixo nível syscall, que provê uma interface primitiva para as chamadas adjacentes ao sistema.

A seguir temos uma definição de tipo: a palavra-chave type introduz uma declaração de tipo, neste caso uma estrutura de dados chamada File. Para tornar as cosas um pouco mais interessantes, nosso tipo File inclui o nome do arquivo ao qual o descritor do arquivo se refere.

Como File começa com uma letra maiúscula, o tipo está disponível fora da package, ou seja, por usuários da package. Em Go, a regra sobre visibilidade da informação é simples: se o nome (de um tipo em nível superior, função, método, constante, variável ou de um campo ou método de estrutura) começa com maiúscula, usuários da package podem vê-lo. Caso contrário, o nome e consequentemente a coisa que está sendo nomeada é visível apenas dentro da package onde é declarada. Isto é mais do que uma convenção; a regra é forçada pelo compilador. Em Go, o termo para nomes publicamente visíveis é “exportado”.
No caso de File, todos os seus campos começam com letras minúsculas e portanto invisíveis para usuários, mas lhe daremos (a File) em breve alguns métodos com letras maiúsculas.
Primeiro, no entanto, aqui está um factory para criar um File:

    func newFile(fd int, name string) *File {
        if fd < 0 {
            return nil
        }
        return &File{fd, name}
    }

This returns a pointer to a new File structure with the file descriptor and name filled in. This code uses Go's notion of a ''composite literal'', analogous to the ones used to build maps and arrays, to construct a new heap-allocated object. We could write

Isto retorna um ponteiro para uma nova estrutura File com o descritor e o nome do arquivo preenchidos. Este código usa a notação Go de um "literal composto", análogo àqueles usados para construir maps e arrays, para construir um novo objeto alocado na área de heap. Poderíamos escrever:

    n := new(File);
    n.fd = fd;
    n.name = name;
    return n

mas para estruturas simples como File, é mais fácil retornar o endereço de um literal composto usado apenas uma vez, como é feito aqui na linha 21.

Podemos usar o factory para construir algumas variáveis exportadas familiares do tipo *File:

    func Open(name string, mode int, perm int) (file *File, err os.Error) {
        r, e := syscall.Open(name, mode, perm);
        if e != 0 {
            err = os.Errno(e);
        }
        return newFile(r, name), err
    }

Existe uma série de novidades nestas poucas linhas. Primeiro, Open retorna múltiplos valores, um File e um erro (mais sobre erros em breve). Declaramos o retorno multi-valor como uma lista de declarações entre parênteses; sintaticamente parecem como uma segunda lista de parâmetros. A função syscall.Open também tem um retorno multi-valor, que podemos apanhar com a declaração multi-variável na linha 31; ela declara r e e para armazenar os dois valores, ambos do tipo int (embora você tenha que dar uma ollhada na package syscall para ver isto). Finalmente, a linha 35 retorna dois valores: um ponteiro para o novo File e um erro. Se syscall.Open falhar, o descritor r será negativo e newFile retornará nil.

Sobre estes erros: A biblioteca os inclui uma noção geral de erro. É uma boa idéia usar suas facilidades em suas interfaces. como fizemos aqui, para manipulação consistente de erros ao longo de códigos Go. Em Open, usamos uma conversão para traduzir inteiros de valor da variável Unix errno para um tipo inteiro os.Errno, implementado por os.Error.

Agora que podemos construir Files, precisamos escrever métodos para eles. Para declarar um método de um tipo, definimos uma função para ter um receptor explícito daquele tipo, colocado entre parênteses antes do nome da função. Aqui estão alguns métodos para *File, cada um deles declarando uma variável receptora file.

    func (file *File) Close() os.Error {
        if file == nil {
            return os.EINVAL
        }
        e := syscall.Close(file.fd);
        file.fd = -1;  // so it can't be closed again
        if e != 0 {
            return os.Errno(e);
        }
        return nil
    }

 func (file *File) Read(b []byte) (ret int, err os.Error) {
    if file == nil {
      return -1, os.EINVAL
   }
   r, e := syscall.Read(file.fd, b);
   if e != 0 {
    err = os.Errno(e);
   }
   return int(r), err
 }

 func (file *File) Write(b []byte) (ret int, err os.Error) {
   if file == nil {
     return -1, os.EINVAL
   }
   r, e := syscall.Write(file.fd, b);
   if e != 0 {
     err = os.Errno(e);
   }
   return int(r), err
 }

 func (file *File) String() string {
   return file.name
 }

Não existe um this implícito e a variável receptora deve ser usada para acessar membros da estrutura. Métodos não são declarados dentro da declaração da estrutura propriamente. A declaração da estrutura define apenas dados membros. De fato, métodos podem ser criados por quase qualquer tipo que você declare, como um inteiro ou array, não apenas para estruturas (structs). Veremos um exemplo com arrays mais tarde.

O método String é assim chamado por uma convenção de impressão que descreveremos mais tarde.

Os métodos usam a variável pública os.EINVAL para retornar o (versão os.Error de) código de erro EINVAL do Unix. A biblioteca os define um conjunto padrão destes valores de erro.

Podemos agora usar nossa nova package:

 package main

 import (
 "./file";
 "fmt";
 "os";
 )

func main() {
   hello := []byte{'h', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '\n'};
   file.Stdout.Write(hello);
   file, err := file.Open("/does/not/exist", 0, 0);
   if file == nil {
     fmt.Printf("can't open file; err=%s\n", err.String());
     os.Exit(1);
   }
 } 

O "./" no import em "./file" diz ao compilador para usar sua própria package ao invés de alguma coisa do diretório de packages instaladas.

Finalmente podemos executar o programa:
    % helloworld3
    hello, world
    can't open file; err=No such file or directory
    %

Continua...
Abraço
]]>
			http://alovasconcelos.net/blog/?feed=rss2&p=665
		1
		
		
		
		http://alovasconcelos.net/blog/?p=652
		http://alovasconcelos.net/blog/?p=652#comments
		Tue, 24 Nov 2009 00:47:38 +0000
		ALOVasconcelos
				
		
		
		
		
		
		

		http://alovasconcelos.net/blog/?p=652
		
			Um Interlúdio sobre Alocação
 [Voltar ao menu]
A maioria dos tipos em Go são valores. Se você tem um int ou um struct ou um array, a atribuição copia o conteúdo do objeto. Para alocar um novo valor, use new(), que retorna um ponteiro para o espaço alocado.
type T struct { a, b int }
var t *T = new(T);

ou o mais idiomático (socorro!):
t := new(T);

Alguns tipos – maps, slices e channels (veja abaixo) – tem semântica de referência. Se você está guardando um slice ou um map e modifica seu conteúdo, outras variáveis fazendo referência ao mesmo dado adjacente “enxergarão” a modificação. Para estes três tipos você precisa usar a função interna make():
    m := make(map[string]int);
A declaração inicializa o novo map, pronto para armazenar entradas. Se você apenas declara o map, como em
    var m map[string]int;
ela (a declaração) cria uma referência nil que não pode armazenar coisa alguma. Para usar o map, você deve primeiro inicializa-lo e referencia-lo, usando make() ou por atribuição a partir de um map existente.
Observe que new(T) retorna o tipo *T, enquanto make(T) retorna o tipo T. Se voce (por engano) aloca um objeto de referência com new(), receber um ponteiro para uma referência nil, equivalente a declarar uma variável não inicializada e pegar o seu endereço.
Um Interlúdio sobre Constantes
 [Voltar ao menu]

Embora inteiros estejam disponíveis em vários tamanhos em Go, inteiros constantes não. Não existem constantes como 0LL oo 0×0UL. Ao invés disso, constantes inteiras são interpretadas como valores de grande precisão que podem provocar estouro (overflow) quando são atribuidos a variáveis inteiras com precisão insuficiente para representar o valor.
    const hardEight = (1 << 100) >> 97  // válido
Há nuances que devem merecer reconsiderações nas longas sentenças da especificação da linguagem, mas aqui estão alguns exemplos ilustrativos:
var a uint64 = 0  // a tem tipo uint64, valor 0
    a := uint64(0)    // equivalente; usa a "conversão"
    i := 0x1234       // i assume tipo default: int
    var j int = 1e6   // legal - 1000000 é representável como um int
    x := 1.5          // um float
    i3div2 := 3/2     // divisão inteira - resulta 1
    f3div2 := 3./2.   // divisão de ponto flutuante - resulta 1.5
Conversões só funcionam para casos simples, como convertendo ints de um sinal ou tamanho para outro e entre nts e floats, mais alguns poucos casos simples. Não existem conversões numéricas automáticas de qualquer tipo em Go, além daquela de fazer constantes terem um tamanho e tipo concreto quando atribuidas a uma variável.
Continua…
Abraço

[Voltar ao menu]

Go possui alguns tipos familiares como int e float, que representam valores de tamanho apropriado para a máquina. Também define tipos de tamanhos explícitos com int8, float64 e assim por diante, além de tipos inteiros sem sinal, como uint, uint32, etc. Estes são tipos distintos; mesmo se int e int32 tenham ambos o 32 bits de tamanho, eles não são do mesmo tipo. Existe também um byte, sinônimo para uint8, que é o tipo de elemento para strings.

N.T. – em algumas linguagens, o tamanho ocupado em memória por dados de cada tipo, varia de acordo com a arquitetura da máquina. Em Go, podemos usar tipos com tamanhos fixos, independentes portanto da arquitetura, como int8, por exemplo.

Falando de string, este é um tipo interno também. Strings são valores imutáveis – eles não são apenas arrays de valores do tipo byte. Uma vez que tenha montado um valor string, você não pode altera-lo, embora – é claro – possa mudar uma variável string simplesmente atribuindo a ela um novo valor. Este trecho de código de strings.go é um código válido:

s := "hello";
if s[1] != 'e' { os.Exit(1) }
s = "good bye";
var p *string = &s;
*p = "ciao";

Contudo, as declarações seguintes são inválidas, porque podem modificar um valor string:

s[0] = 'x';
(*p)[1] = 'y';

Em termos de C++, strings Go são um pouco como constantes strings, enquanto que ponteiros são análogos a referências a constantes string.
Sim, os ponteiros existem. Contudo, Go simplifica um pouco o uso deles.

Arrays são declarados assim:

var arrayOfInt [10]int;

Arrays, como strings, são valores, mas são mutáveis. Isto difere do C, no qual arrayOfInt seria usado como um ponteiro para int. Em Go, como arrays são valores, é importante (e útil) falar sobre ponteiros para arrays.
O tamanho do array é parte do seu tipo; contudo, pode-se declarar uma variável slice, para a qual pode-se atribuir um ponteiro para qualquer array com o mesmo tipo de elemento ou – muito mais comumente – uma expressão slice na forma a[low : high], representando o subarray indexado por low até high-1. Slices parecem muito com arrays, mas não têm um tamanho explícito ([] versus [10]) e fazem referência a um segmento de um subjacente, frequentemente anônimo, array simples. Slices múltiplos podem compartilhar dados se eles representarem partes de um mesmo array; arrays múltplos nunca podem compartilhar dados.

Slices são mais comuns em programas Go do que arrays simples; eles são mais flexíveis, têm referência semântica e são eficientes. O que falta é o controle preciso do esquema de armazenamento de um array simples; se você quer ter uma centena de elementos de um array armazenados dentro da sua estrutura, deve usar um array simples.
Ao passar um array para uma função, quase sempre você desejará declarar o parâmetro formal como um slice. Quando você chamar a função, pegue o endereço do array e Go criará (eficientemente) a referência para um slice e o passará.
Usando slices, pode-se escrever esta função (do programa sum.go – N.T. – disponível no diretório go/doc/progs):

func sum(a []int) int {   // retorna um int
     s := 0;
     for i := 0; i < len(a); i++ {
         s += a[i]
     }
     return s
}

e chama-la da segunte forma:

     s := sum(&[3]int{1,2,3});  // um slice do array é passado para a função sum

Note como o tipo de retorno (int) é definido para a função sum, declarando-o depois da lista de parâmetros.
A expressão [3]int{1,2,3} - um tipo seguido de uma expressão entre chaves - é um construtor para o valor, neste caso um array de 3 ints. Colocar um & (ampersand) na frente, fornece o endereço de uma única instância do valor. Passamos o ponteiro para sum() promovendo-o (implicitamente) para um slice.

Se você está criando um array simples, mas quer que o compilador conte seus elementos para você, use ... como tamanho do array:

 s := sum(&[...]int{1,2,3});

Na prática, no entanto, a não ser que você seja muito meticuloso sobre o esquema de armazenamento dentro de uma estrutura de dados, um slice por si mesmo - usando colchetes e sem & - é tudo de que você precisa:

    s := sum([]int{1,2,3});

Existem também os maps, os quais você pode inicializar assim:

m := map[string]int{"one":1 , "two":2}

A função interna len(), que retorna o número de elementos, faz sua primeira aparição em sum. Ela trabalha com strings, arrays, slices, maps e channels.
A propósito, outra cosa que funciona com strings, arrays, slices, maps e channels é a cláusula range em loops for. Ao invés de escrever

for i := 0; i < len(a); i++ { ... }

parao iterar pelos elementos de um slice (ou map, ou...), podemos escrever

for i, v := range a { ... }

Isto atribui a i o índice do array e a v o valor de sucessivo elementos do objeto do range. Veja o documento Effective Go para mais exemplos de seu uso (do range).

N.T. Este utilização de range, assemelha-se à estrutura foreach encontrada em algumas linguagens de programação. Está nos meus planos, se conseguir tempo para isso, a tradução do documento Effective Go também.

Continua...

Abraço