Go – specifiche del linguaggio – 2

Continuo l’esame della sintassi di Go, iniziata qualche post orsono. Lo so è un argomento un tantino boringnoioso ma potrebbe servire. Anzi di sicuro serve almeno a una persona: me. Se devo raccontare agli altri –sempre che ci siano “altri” che abbiano la compiacenza di starmi a sentire– devo prima capire, o almeno avere un’idea, di cosa sto parlando.

Dai, prima o poi finisce. Allora continuo l’esame del documento The Go Programming Language Specification

I tipi struct
Una struct è una sequenza di elementi con nome, chiamati campi, ognuno dei quali ha un nome e un tipo. Praticamente come in C.

// una struct vuota
struct {}

// una struct con 6 campi
struct {
	x, y int
	u float32
	_ float32  // padding
	A *[]int
	F func()
}

Un campo (field) di cui è dichiarato il tipo ma non il nome è un campo anonimo (detto anche campo embedded). Può essere di un tipo T specificato o un puntatore a un tipo *T e T può non essere un tipo puntatore (?). Mi sono decisamente perso, vediamo se con un paio di esempi la cosa è più chiara

// A struct with four anonymous fields of type T1, *T2, P.T3 and *P.T4
struct {
	T1        // field name is T1
	*T2       // field name is T2
	P.T3      // field name is T3
	*P.T4     // field name is T4
	x, y int  // field names are x and y
}

La dichiarazione seguente è illegale perché i nomi dei campi devono essere unici nella struct

struct {
	T         // conflicts with anonymous field *T and *P.T
	*T        // conflicts with anonymous field T and *P.T
	*P.T      // conflicts with anonymous field T and *T
}

Campi e metodi di un campo anonimo sono promossi a campi ordinari e metodi della struct. Per una struct S di tipo T si applicano le seguenti regole:

  • se S contiene un campo anonimo T, il metodo set di S include il metodo set di T.
  • se S contiene un campo anonimo *T, il metodo set di S include il metodo set di *T (il quale include il metodo set di T).
  • se S contiene un campo anonimo T o *T, il metodo set di *S include il metodo set di *T (il quale include il metodo set di T).

Una dichiarazione di campo può essere seguita da un’opzionale tag, stringa letterale, che diventa un attributo per tutti i campi nella corrispondete dichiarazione del capo. I tag sono resi visibili attraverso una reflection interface ma sono altrimenti ignorati. (?)

// A struct corresponding to the TimeStamp protocol buffer.
// The tag strings define the protocol buffer field numbers.
struct {
	microsec  uint64 "field 1"
	serverIP6 uint64 "field 2"
	process   string "field 3"
}

Ecco mi sembra il caso di raccomandarmi a Sua Pastosità FSM che possa assistermi quando dovrò affrontare questi casi. Poi magari è molto più semplice di quello che sembra, come il caso dell’articolo determinativo. In italiano ce ne sono ben 6 (sei) quando le lingue sensate ne hanno molti meno (tre in francese, quattro in spagnolo) o addirittura uno solo come l’inglese. Poi ci sono quelli che ne fanno a meno (il russo) ma lì le cose si complicano e devi fare i conti con le desinenze; i più bravi (i tedeschi) hanno sia gli articoli che le desinenze. Eppure in ogni caso ci si abitua e a qualcuno (non io) sembra la cosa più naturale e ottimevole.

Tipi puntatori
I puntatori sono la croce e delizia della programmazione! Innumerevoli sono gli errori derivanti dalla gestione disinvolta degli stessi. Parecchi linguaggi non li hanno, almeno non visibili, ma poi ti sembra che manchi qualcosa, come nella cucina kosher o in quella vegetariana.
Go non si pone questi problemi: i suoi autori sono quelli che hanno fatto il C e i puntatori ci sono, eccome, in tutta la loro magnificenza. OK, bisognerà fare attenzione ma

quando il gioco si fa duro i duri cominciano a giocare
(John Belushi)

o meglio, in originale, secondo Wikiquote

when the goin’ gets tough … the tough get goin
(John Belushi – John ‘Bluto’ Blutarsky)

Tornando al dunque: un tipo puntatore denota l’insieme di tutti i puntatori a variabili di un dato tipo, chiamato il tipo base del puntatore. Il valore di un puntatore non inizializzato è nil.

*int
*map[string] *chan int

I tipi funzione
Un tipo funzione denota l’insieme di tutte le funzioni con lo stesso parametro e gli stessi tipi di risultato. Il valore di un tipo funzione non inizializzato è nil.

FunctionType   = "func" Signature
Signature      = Parameters [ Result ]
Result         = Parameters | Type 
Parameters     = "(" [ ParameterList [ "," ] ] ")"
ParameterList  = ParameterDecl { "," ParameterDecl }
ParameterDecl  = [ IdentifierList ] [ "..." ] Type

Nella lista dei parametri o dei risultati, i nomi (IdentifierList) devono o essere tutti presenti o tutti assenti. Se presenti ogni nome deve corrispondere a un elemento (parametro o risultato) del tipo specificato; se assenti, ciascun tipo corrisponde a un elemento di tale tipo. Le liste di parametri e risultati sono sempre tra parentesi a meno che ci sia solo esattamente un unico risultato senza nome.
Il parametro finale di una funzione può avere il prefisso Una funzione di questo tipo è chiamata variadic e può essere invocata con zeo o più argomenti pre questo parametro.

func()
func(x int)
func() int
func(prefix string, values ...int)
func(a, b int, z float32) bool
func(a, b int, z float32) (bool)
func(a, b int, z float64, opt ...interface{}) (success bool)
func(int, int, float64) (float64, *[]int)
func(n int) func(p *T)

Per oggi basta, ma rimanete collegati, la storia continua :)
Nota: Oggi, 1° aprile, Gopher Gordon la nostra mascotte è impegnato; ringraziamo Babel Fish che l’ha sostituito ;-)

About these ads
Post a comment or leave a trackback: Trackback URL.

Commenti

  • glipari  On 1 aprile 2011 at 21:38

    Devo dire che stavolta non ci ho capito una mazza. Sarà il primo aprile?
    1) Che è P.T3? Forse P è forse un’altra struttura?
    2) Che è il metodo set?

    Dovrai farmi qualche esempietto concreto…:)

    • juhan  On 1 aprile 2011 at 21:46

      OK! rivedo il tutto e esempisco. Non subito che sono cotto. CMQ è (o vorrebbe essere) una traduzione al documento linkato, che (ahemm…) non padroneggio ancora come vorrei. Mi ricorda moltissimo quando ho affrontato K&R (senza avere il compilatore) e lo riempivo di “?” (a matita perché [a dedursi]): ecco sono + o – a quel punto :-(

  • maillots basket nba  On 12 ottobre 2011 at 16:31

    That’s an all round amazingly written blog

  • generator  On 25 novembre 2011 at 08:10

    That was a truly amazing article!!

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...

Iscriviti

Ricevi al tuo indirizzo email tutti i nuovi post del sito.

Unisciti agli altri 77 follower

%d blogger cliccano Mi Piace per questo: