Andare esempi e i modi di dire

Non c’è un sacco di codice di Andare a imparare la lingua, e sono sicuro che non sono l’unico a sperimentare con esso. Quindi, se hai scoperto qualcosa di interessante riguardo la lingua, si prega di postare qui un esempio.

Sto cercando anche

  • idiomatiche, modi di fare le cose Andare,
  • C/C++ stile di pensiero “porting” per Andare,
  • trabocchetti sulla sintassi,
  • nulla di interessante, davvero.
  • BRACCIO di supporto, ad esempio 8-bit o 16-bit. D lingua ancora non.
  • La biblioteca (golang.org/pkg) è un’ottima fonte per imparare come va utilizzato. Personalmente, trovo che imparare come strutture di dati sono implementate è utile per imparare la lingua.



25 Replies
  1. 35

    Posticipa istruzioni

    Un “rimandare” istruzione richiama una funzione la cui esecuzione è differita al momento circostante funzione restituisce.

    DeferStmt = “rinviare” Espressione .

    L’espressione deve essere una funzione o di un metodo di chiamata. Ogni volta che il “rinviare” istruzione viene eseguita, i parametri per la funzione di chiamata vengono valutati e salvato di nuovo, ma la funzione non viene chiamata. Differite chiamate di funzione sono eseguiti in ordine LIFO immediatamente prima circostante funzione restituisce, ma dopo i valori di ritorno, se del caso, sono state valutate.

    lock(l);
    defer unlock(l);  //unlocking happens before surrounding function returns
    
    //prints 3 2 1 0 before surrounding function returns
    for i := 0; i <= 3; i++ {
        defer fmt.Print(i);
    }

    Aggiornamento:

    defer è ora anche il idiomatiche modo di gestire la panic in un eccezione-come modo:

    package main
    
    import "fmt"
    
    func main() {
        f()
        fmt.Println("Returned normally from f.")
    }
    
    func f() {
        defer func() {
            if r := recover(); r != nil {
                fmt.Println("Recovered in f", r)
            }
        }()
        fmt.Println("Calling g.")
        g(0)
        fmt.Println("Returned normally from g.")
    }
    
    func g(i int) {
        if i > 3 {
            fmt.Println("Panicking!")
            panic(fmt.Sprintf("%v", i))
        }
        defer fmt.Println("Defer in g", i)
        fmt.Println("Printing in g", i)
        g(i+1)
    }
    • Che cosa è bene?
    • Sembra il buon vecchio RAII (esplicito).
    • +1 dato che ho letto un sacco di Andare, ma non sono riuscita a vedere questo (fino a quando tu mi hai mostrato)!
    • Intelligente, anche se avrebbe più senso per me se rinviare le dichiarazioni di cui vengono eseguite in ordine FIFO (superiore e inferiore), ma forse solo a me…
    • Cool. Mi ricorda scrop guardie D digitalmars.com/d/2.0/exception-safe.html
    • se si confronta con blocchi di “provare:..infine:” LIFO nidi nello stesso modo. Per la risorsa di aprire/chiudere coppie ecc, di nidificazione, come questo è l’unica cosa che abbia un senso (il Primo apri chiudi ultimi).
    • Credo che dipende da come si leggono le defer dichiarazioni in testa :). Poiché è in ordine LIFO, si deve leggere “indietro” per vedere come è il rilascio di cose (defer CloseDatabase; defer CloseTable significa “Chiudere il database DOPO la chiusura del tavolo”). Se non sapevo meglio, avrei scritto come defer CloseTable; defer CloseDatabase perché il mio primo istinto sarebbe quello di leggere come “Chiudere la tabella di prima, QUINDI chiudere il database.”). Ma al contrario, per me, è corretto a qualcun altro 😉
    • Come Kinopiko, mi chiedo che cosa sia bene per loro nella vita reale?
    • No, @KonradRudolph, RAII tratta di oggetti di terminazione, non solo funzioni. “Rinviare” è più simile a try-catch.
    • RAII è solo superficialmente sull’oggetto della risoluzione. RAII è utilizzato per implementare la stessa cosa che si ottiene da tryfinally (non catch). Non sono la stessa cosa, ma sono utilizzati per sostenere la stessa semantica. In altre parole: dove vi piacerebbe utilizzare defer in Go devi utilizzare RAII in lingue che lo supportano (principalmente C++).
    • assolutamente no. Non si capisce cosa è RAII. Cercare di attuare i mutex con try-catch (è divertente).
    • Mi dispiace ma devi farlo in modo sbagliato. Mi pare di capire RAII (basta cercare di Overflow dello Stack per il mio contributo sull’argomento), ma non so di cosa si intende con l’attuazione di un mutex via try–catch, non ho mai suggerito di farlo. Si può, ovviamente, fare try–finally, però.
    • google po ‘ di mutex e RAII 🙂 Si è tentato di dimostrare che defer è la stessa cosa come RAII, anche a dispetto del fatto che defer funziona solo in ambito di funzione. Così ho cercato di mostrare che con RAII si può fare le cose che sono molto più difficili da mettere in pratica senza RAII. Abbastanza su di esso. Se pensate ancora che RAII e defer è la stessa cosa – non abbiamo nulla di cui parlare.
    • Non ho mai cercato di dimostrare che RAII è strettamente stesso come defer, solo che sono utilizzati per risolvere gli stessi problemi. Ma se si vuole avere un mutex con defer, è abbastanza facile (è un esempio tipico di utilizzo della maniglia con try–finally, e quindi facilmente adattabile a defer): m := mutex{}; defer m.unlock(); m.lock(); – spero che ho avuto il Go sintassi ragione: io non lo uso mai, ma io uso la stessa routine in R (defer è chiamato on.exit).

  2. 25

    Andare oggetto file comprende in realtà un chiaro intestazione:

    [email protected] ~/workspace/go/euler31 $ 6g euler31.go
    [email protected] ~/workspace/go/euler31 $ cat euler31.6
    amd64
      exports automatically generated from
      euler31.go in package "main"
        import
    
    $$  //exports
      package main
        var main.coin [9]int
        func main.howmany (amount int, max int) (? int)
        func main.main ()
        var main.initdone· uint8
        func main.init ()
    
    $$  //local types
      type main.dsigddd_1·1 struct { ? int }
    
    $$
    
    !
    <binary segment>
    • Che è più simile a una funzione nascosta di un idiomatiche esempio
    • Questo è impressionante!
  3. 22

    Ho visto un paio di persone che lamentano il ciclo for, lungo le linee di “perché dobbiamo dire i = 0; i < len; i++ in questo giorno ed età?”.

    Io non sono d’accordo, mi piace il costrutto for. È possibile utilizzare la versione lunga, se lo si desidera, ma il idiomatiche Go è

    var a = []int{1, 2, 3}
    for i, v := range a {
        fmt.Println(i, v)
    }

    Il for .. range costruire loop su tutti gli elementi e fornisce due valori – indice i e il valore v.

    range funziona anche sulle mappe satellitari.

    Ancora, se non ti piace for in qualsiasi forma, è possibile definire each, map etc. in poche righe:

    type IntArr []int
    
    //'each' takes a function argument.
    //The function must accept two ints, the index and value,
    //and will be called on each element in turn.
    func (a IntArr) each(fn func(index, value int)) {
        for i, v := range a {
            fn(i, v)
        }
    }
    
    func main() {
        var a = IntArr([]int{2, 0, 0, 9}) //create int slice and cast to IntArr
        var fnPrint = func(i, v int) {
            fmt.Println(i, ":", v)
        } //create a function
    
        a.each(fnPrint) //call on each element
    }

    stampe

    0 : 2
    1 : 0
    2 : 0
    3 : 9

    Sto iniziando a come Andare a un sacco 🙂

    • Se range è solo bello, se viene compilato il codice stesso come il per-3 loop.
  4. 19

    Andare e ottenere il vostro stackoverflow reputazione

    Questa è una traduzione di questa risposta.

    package main
    
    import (
        "json"
        "fmt"
        "http"
        "os"
        "strings"
    )
    
    func die(message string) {
        fmt.Printf("%s.\n", message);
        os.Exit(1);
    }
    
    func main() {
        kinopiko_flair := "https://stackoverflow.com/users/flair/181548.json"
        response, _, err := http.Get(kinopiko_flair)
        if err != nil {
            die(fmt.Sprintf("Error getting %s", kinopiko_flair))
        }
    
        var nr int
        const buf_size = 0x1000
        buf := make([]byte, buf_size)
    
        nr, err = response.Body.Read(buf)
        if err != nil && error != os.EOF {
            die(fmt.Sprintf("Error reading response: %s", err.String()))
        }
        if nr >= buf_size { die ("Buffer overrun") }
        response.Body.Close()
    
        json_text := strings.Split(string(buf), "\000", 2)
        parsed, ok, errtok := json.StringToJson(json_text[0])
        if ! ok {
            die(fmt.Sprintf("Error parsing JSON %s at %s", json_text, errtok))
        }
    
        fmt.Printf("Your stackoverflow.com reputation is %s\n", parsed.Get ("reputation"))
    }

    Grazie a Scott Galles per aiutare con .Read ().

    Questo sembra abbastanza goffo ancora, con le due stringhe e due buffer, quindi, se tutto Va esperti consigli, fammi sapere.

    • Io non sono sicuro di quello che doveva essere sbagliato con la formattazione; ho restaurato.
    • L’Andare autori raccomandano di gofmt il codice 🙂
    • Io non riesco a compilarlo: $ ../go/src/cmd/6g/6g COSÌ.andare COSÌ.go:34: undefined: json.StringToJson
    • il linguaggio è cambiato da quando ho fatto questo.
    • Sì, sai, forse, che cosa è l’equivalente del StringToJson? È utilizzato per impostare un generatore internamente, ora si deve fornire loro con un predefiniti struttura nativa?
  5. 19

    Ecco un bel esempio di iota da Kinopiko post:

    type ByteSize float64
    const (
        _ = iota;   //ignore first value by assigning to blank identifier
        KB ByteSize = 1<<(10*iota)
        MB
        GB
        TB
        PB
        YB
    )
    
    //This implicitly repeats to fill in all the values (!)
    • Si noti che il punto e virgola sono inutili.
  6. 18

    È possibile scambiare le variabili di parallelo di assegnazione:

    x, y = y, x
    
    //or in an array
    a[j], a[i] = a[i], a[j]

    semplice ma efficace.

  7. 18

    Ecco un idioma dal Efficace Andare pagina

    switch {
    case '0' <= c && c <= '9':
        return c - '0'
    case 'a' <= c && c <= 'f':
        return c - 'a' + 10
    case 'A' <= c && c <= 'F':
        return c - 'A' + 10
    }
    return 0

    L’istruzione switch switch su true quando non si esprime. Quindi, questo è equivalente a

    if '0' <= c && c <= '9' {
        return c - '0'
    } else if 'a' <= c && c <= 'f' {
        return c - 'a' + 10
    } else if 'A' <= c && c <= 'F' {
        return c - 'A' + 10
    }
    return 0

    Al momento, l’interruttore versione sembra un po ‘ più pulito di me.

    • Whoa, completamente strappato da VB. 😉 (Switch True …)
    • mi ha battuto! 🙂 Ho usato quel linguaggio in codice VB6 prima e sicuramente può aiutare la leggibilità in determinate situazioni.
    • Che cosa è ” <=’? Essa è collegata alla ‘<-‘ ?
    • meno-che-o-uguale.
  8. 17

    Gli interruttori di tipo:

    switch i := x.(type) {
    case nil:
        printString("x is nil");
    case int:
        printInt(i);  //i is an int
    case float:
        printFloat(i);  //i is a float
    case func(int) float:
        printFunction(i);  //i is a function
    case bool, string:
        printString("type is bool or string");  //i is an interface{}
    default:
        printString("don't know the type");
    }
  9. 14

    Denominato parametri di risultato

    Restituzione o di risultato “parametri” di un
    Vai funzione può essere dato un nome e
    utilizzati come normali variabili, proprio come
    i parametri in arrivo. Quando denominato,
    sono inizializzati a zero
    i valori per il loro tipo, quando il
    la funzione inizia; se la funzione
    esegue un’istruzione return, senza
    gli argomenti, i valori correnti delle
    parametri di risultato vengono utilizzati come
    valori restituiti.

    I nomi non sono obbligatori, ma sono
    codice breve e chiaro:
    sono di documentazione. Se abbiamo il nome del
    risultati di nextInt diventa evidente
    che è tornato int è che.

    func nextInt(b []byte, pos int) (value, nextPos int) {

    Perché denominato risultati vengono inizializzati e legato ad un disadorno di ritorno, essi possono semplificare e chiarire. Ecco una versione di io.ReadFull che li usi bene:

    func ReadFull(r Reader, buf []byte) (n int, err os.Error) {
        for len(buf) > 0 && err == nil {
            var nr int;
            nr, err = r.Read(buf);
            n += nr;
            buf = buf[nr:len(buf)];
        }
        return;
    }
    • Sono curioso — qualsiasi altro linguaggio di avere questo?
    • Matlab ha qualcosa di simile.
    • pascal utilizza una sintassi simile a quella per la restituzione di un valore.
    • Per chi non lo sapesse, in Pascal è in stile classico, di assegnare il valore di ritorno e il nome della funzione.
    • FORTRAN abbastanza molto è questo.
  10. 14

    Da James Antill risposta:

    foo := <-ch     //This blocks.
    foo, ok := <-ch //This returns immediately.

    Inoltre, una potenziale insidia: il sottile differenza tra la ricezione e invio di operatori:

    a <- ch //sends ch to channel a
    <-ch    //reads from channel ch
  11. 13
    /* 
     * How many different ways can £2 be made using any number of coins?
     * Now with 100% less semicolons!
     */
    
    package main
    import "fmt"
    
    
    /* This line took me over 10 minutes to figure out.
     *  "[...]" means "figure out the size yourself"
     * If you only specify "[]", it will try to create a slice, which is a reference to an existing array.
     * Also, ":=" doesn't work here.
     */
    var coin = [...]int{0, 1, 2, 5, 10, 20, 50, 100, 200}
    
    func howmany(amount int, max int) int {
        if amount == 0 { return 1 }
        if amount < 0 { return 0 }
        if max <= 0 && amount >= 1 { return 0 }
    
        //recursion works as expected
        return howmany(amount, max-1) + howmany(amount-coin[max], max)
    }
    
    
    func main() {
        fmt.Println(howmany(200, len(coin)-1))
    }
    • Vorrei suggerire di rimuovere il nome di problem solving sito così come il numero di id. Forse riformulare la domanda. Per non rovinare il problema a qualcuno di inciampare su di esso. O cercando di imbrogliare la ricerca per il problema sul net per quella materia.
    • Per la cronaca: questo è l’algoritmo da algorithmist.com/index.php/Coin_Change È il primo risultato di Google per “cambio monete”.
  12. 13

    Mi piace che è possibile ridefinire i tipi, tra cui le primitive come int, come molte volte come si desidera, collegare diversi metodi. Come definire una RomanNumeral tipo:

    package main
    
    import (
        "fmt"
        "strings"
    )
    
    var numText = "zero one two three four five six seven eight nine ten"
    var numRoman = "- I II III IV V VI VII IX X"
    var aText = strings.Split(numText, " ")
    var aRoman = strings.Split(numRoman, " ")
    
    type TextNumber int
    type RomanNumber int
    
    func (n TextNumber) String() string {
        return aText[n]
    }
    
    func (n RomanNumber) String() string {
        return aRoman[n]
    }
    
    func main() {
        var i = 5
        fmt.Println("Number: ", i, TextNumber(i), RomanNumber(i))
    }

    Che stampa

    Number:  5 five V

    Il RomanNumber() chiamata è essenzialmente un cast, ridefinisce il tipo int come un di più specifico tipo di int. E Println() chiamate String() dietro le quinte.

  13. 12

    La restituzione di un canale

    Questo è un vero e proprio linguaggio che è molto importante: come nutrire i dati in un canale e chiudere in seguito. Con questo si può fare semplice iteratori (dato che il raggio di accettare un canale) o filtri.

    //return a channel that doubles the values in the input channel
    func DoublingIterator(input chan int) chan int {
        outch := make(chan int);
        //start a goroutine to feed the channel (asynchronously)
        go func() {
            for x := range input {
                outch <- 2*x;    
            }
            //close the channel we created and control
            close(outch);
        }();
        return outch;
    }
    • +1. Inoltre, è possibile passare i canali attraverso i canali.
    • Ma attenzione a non rompere fuori di un per x := range chan {} loop, ti perdita la goroutine, e tutta la memoria di riferimento.
    • come circa defer close(outch); come prima istruzione del goroutine?
    • Rinviare le code di una dichiarazione per l’esecuzione quando la funzione restituisce, non importa da quale punto di ritorno è preso. Ma se il canale di ingresso è mai chiuso, quindi la funzione anonima in questo esempio non lascerà mai il ciclo for.
  14. 11

    Timeout per canale di legge:

    ticker := time.NewTicker(ns);
    select {
        case v := <- chan_target:
            do_something_with_v;
        case <- ticker.C:
            handle_timeout;
    }

    Rubato Davies Liu.

  15. 11
    for {
        v := <-ch
        if closed(ch) {
            break
        }
        fmt.Println(v)
    }

    Dato intervallo di verifica automaticamente la presenza di un canale chiuso, si può ridurre a questo:

    for v := range ch {
        fmt.Println(v)
    }
  16. 9

    C’è un sistema che è possibile utilizzare in $GOROOT/src

    Impostare il makefile con

    TARG=foobar           # Name of package to compile
    GOFILES=foo.go bar.go # Go sources
    CGOFILES=bang.cgo     # Sources to run cgo on
    OFILES=a_c_file.$O    # Sources compiled with $Oc
                          # $O is the arch number (6 for x86_64)
    
    include $(GOROOT)/src/Make.$(GOARCH)
    include $(GOROOT)/src/Make.pkg

    È quindi possibile utilizzare gli strumenti di test automatici tramite l’esecuzione di test, o aggiungere il pacchetto e oggetti condivisi da cgo a vostro $GOROOT con make install.

  17. 7

    Un’altra cosa interessante in Go è che godoc. È possibile eseguire un server web sul tuo computer utilizzando

    godoc -http=:8080

    dove 8080 è il numero di porta, e l’intero sito golang.org è quindi disponibile a localhost:8080.

    • È questo un regolare programma o un demone?
    • Non so. <!– 15 –>
    • Si tratta di un programma regolare.
  18. 7

    Questa è un’implementazione di una pila. Illustra l’aggiunta di metodi su un tipo.

    Ho voluto fare lo stack in parte, in una fetta e l’uso della porzione della proprietà, ma anche se ho capito che per lavorare senza il type, non ho potuto vedere la sintassi per la definizione di una fetta con un type.

    package main
    
    import "fmt"
    import "os"
    
    const stack_max = 100
    
    type Stack2 struct {
        stack [stack_max]string
        size  int
    }
    
    func (s *Stack2) push(pushed_string string) {
        n := s.size
        if n >= stack_max-1 {
            fmt.Print("Oh noes\n")
            os.Exit(1)
        }
        s.size++
        s.stack[n] = pushed_string
    }
    
    func (s *Stack2) pop() string {
        n := s.size
        if n == 0 {
            fmt.Print("Underflow\n")
            os.Exit(1)
        }
        top := s.stack[n-1]
        s.size--
        return top
    }
    
    func (s *Stack2) print_all() {
        n := s.size
        fmt.Printf("Stack size is %d\n", n)
        for i := 0; i < n; i++ {
            fmt.Printf("%d:\t%s\n", i, s.stack[i])
        }
    }
    
    func main() {
        stack := new(Stack2)
        stack.print_all()
        stack.push("boo")
        stack.print_all()
        popped := stack.pop()
        fmt.Printf("Stack top is %s\n", popped)
        stack.print_all()
        stack.push("moo")
        stack.push("zoo")
        stack.print_all()
        popped2 := stack.pop()
        fmt.Printf("Stack top is %s\n", popped2)
        stack.print_all()
    }
    • Piuttosto che usare fmt.Printf(...); os.Exit();, è possibile utilizzare panic(...).
    • Che dà una traccia dello stack, che non voglio.
    • Perché è limitato? Va gestito, gc piacerebbe lingua. Il tuo stack può essere così profondo come si desidera. Utilizzare il nuovo append() builtin, che faranno qualcosa di simile C realloc quando è necessario.
    • “Vai, non ha bisogno di generici”, hanno detto.
  19. 4

    Chiamata di c codice di andare

    È possibile accedere a basso livello di go utilizzando il runtime di c.

    C funzioni sono in forma

    void package·function(...)

    (nota il punto separatore è un carattere unicode) dove l’argomento può essere di base go tipi, fette, stringhe etc. Per restituire un valore
    chiamata

    FLUSH(&ret)

    (si può restituire più di un valore)

    Per esempio, per creare una funzione

    package foo
    bar( a int32, b string )(c float32 ){
        c = 1.3 + float32(a - int32(len(b))
    }

    in C si usa

    #include "runtime.h"
    void foo·bar(int32 a, String b, float32 c){
        c = 1.3 + a - b.len;
        FLUSH(&c);
    }

    Nota che ancora deve dichiarare la funzione in un file, e che ti devi prendere cura della memoria di te. Io non sono sicuro se è possibile chiamare le librerie esterne che utilizza questo, potrebbe essere meglio usare cgo.

    Occhiata a $GOROOT/src/pkg/runtime per gli esempi utilizzati in fase di runtime.

    Vedere anche questa risposta per il collegamento di codice c++ con go.

    • Non utilizzare il volo “dot”, davvero? Non mi azzardo a modificare, ma che sembra un po ‘ inaspettato e radicale.
    • Sì, è necessario compilare con 6c (o 8c, ecc). Non credo gcc maniglie unicode identificatori.
    • Penso che la combinazione AltGr+periodo di tipi lo stesso, ma con unicode non sono sicuro. Era molto sorpreso di vedere che in origine ho letto.. perchè non usare qualcosa come ::?
    • Il personaggio è di MEZZO DOT U+00B7. Il parser può essere stata mascherata in modo che si vede questo come un carattere, al fine di dare un valido c identificatore, che, credo, dovrebbe precludere ::.
    • Il ‘·’ è solo un temporaneo hack, rob è stato anche sorpreso, era ancora lì, ha detto che stava per essere sostituito con qualcosa di meno eccentrica.
    • Qual è il linguaggio che secondo frammento di codice scritto in? Non è né andare né C.
    • Quello con includono “runtime.h è c, ho perso l’hash. int32, Corda etc. sono definiti in fase di runtime di intestazione.
    • ALT + MAIUSC + 9(non del tastierino numerico) = ‘·’ su OS X Mav

  20. 3

    Hai fatto vedere questo discorso? Esso mostra un sacco di cose interessanti che si possono fare (fine del discorso)

    • Sì, l’ho fatto. Si riduce a “C’è molto di più in là, passiamo all’argomento successivo.”
    • Sì, a quanto pare molto da dire con un po ‘ di tempo
  21. 3

    Una pila basato sull’altra risposta, ma utilizzando fetta di accodare hanno nessun limite di dimensione.

    package main
    
    import "fmt"
    import "os"
    
    type Stack2 struct {
            //initial storage space for the stack
            stack [10]string
            cur   []string
    }
    
    func (s *Stack2) push(pushed_string string) {
            s.cur = append(s.cur, pushed_string)
    }
    
    func (s *Stack2) pop() (popped string) {
            if len(s.cur) == 0 {
                    fmt.Print("Underflow\n")
                    os.Exit(1)
            }
            popped = s.cur[len(s.cur)-1]
            s.cur = s.cur[0 : len(s.cur)-1]
            return
    }
    
    func (s *Stack2) print_all() {
            fmt.Printf("Stack size is %d\n", len(s.cur))
            for i, s := range s.cur {
                    fmt.Printf("%d:\t%s\n", i, s)
            }
    }
    
    func NewStack() (stack *Stack2) {
            stack = new(Stack2)
            //init the slice to an empty slice of the underlying storage
            stack.cur = stack.stack[0:0]
            return
    }
    
    func main() {
            stack := NewStack()
            stack.print_all()
            stack.push("boo")
            stack.print_all()
            popped := stack.pop()
            fmt.Printf("Stack top is %s\n", popped)
            stack.print_all()
            stack.push("moo")
            stack.push("zoo")
            stack.print_all()
            popped2 := stack.pop()
            fmt.Printf("Stack top is %s\n", popped2)
            stack.print_all()
    }
  22. 3
    const ever = true
    
    for ever {
        //infinite loop
    }
    • ahem. for { /* infinite loop */ } è sufficiente.
    • Di corso. Che è esattamente quello che succede qui. Mi piace il forever parola chiave. Anche Qt è una macro per che.
    • ma Va’, non ha bisogno di una macro o un simpatico alias true per fare questo.
    • Jurily punto è che for ever (dopo aver dichiarato la variabile) è qualcosa di carino si può fare se lo si desidera. Sembra che l’inglese (modulo vuoto).
    • è qualcosa di carino si può fare in C così.. 🙂 #define ever (;;)
  23. 2

    Ci sono un sacco di programmi in test nella directory principale. Esempi:

    • peano.go stampe fattoriali.
    • hilbert.go ha qualche moltiplicazione di matrici.
    • iota.go ha esempi di strano iota cosa.

Lascia un commento