Edit: The problem is that you used Short variable declaration := and you just stored the created *DB value in a local variable and not in the global one. This line: db, err := NewDB(dbinfo) Creates 2 local variables: db and err, and this local db has nothing to do with your global db variable. … Read more
From http://golang.org/ref/spec#Exported_identifiers: An identifier may be exported to permit access to it from another package. An identifier is exported if both: the first character of the identifier’s name is a Unicode upper case letter (Unicode class “Lu”); and the identifier is declared in the package block or it is a field name or method name. … Read more
Important note: Remember that almost none of the following is guaranteed. It is just how it works right now. Why do boxed ZST allocations use the dumb 0x1 address instead of something more meaningful, like in case of “on-stack” values? No address is meaningful for ZSTs. The compiler just use the easiest approach. In particular, … Read more
Because it’s *Faz not Faz. func main() { foo := New().(*Faz) log.Println(foo) }
new allocates zeroed storage for a new item or type whatever and then returns a pointer to it. I don’t think it really matters on if you use new vs short variable declaration := type{} it’s mostly just preference As for pointer2, the pointer2 variable holds its own data, when you do // initializing a … Read more
The address operator returns a pointer to something having a “home”, e.g. a variable. The value of the expression in your code is “homeless”. if you really need a *string, you’ll have to do it in 2 steps: tmp := a(); b := &tmp Note that while there are completely valid use cases for *string, … Read more
The problem here is that shower is an interface type. Interface types in Go hold the actual value and its dynamic type. More details about this: The Laws of Reflection #The representation of an interface. The slice you return contains 2 non-nil values. The 2nd value is an interface value, a (value;type) pair holding a … Read more
You can do that but it’s not optimal: h := handler{is: &[]bool{true}[0]} fmt.Println(*h.is) // Prints true Basically it creates a slice with one bool of value true, indexes its first element and takes its address. No new variable is created, but there is a lot of boilerplate (and backing array will remain in memory until … Read more
The probably unsatisfying answer is “you can’t do it because the spec says so.” The spec says that to use & on something it has to be addressable or a compound literal, and to be addressable it has to be “a variable, pointer indirection, or slice indexing operation; or a a field selector of an … Read more
Your assumptions are correct. About #3, Go is concurrent language and passing by reference in goroutines make them all read same structure which is safe, but also make them modify same structure which is dangerous.