What does the "make" function do to a map in this context

I am new to Go and was looking for a tutorial on forms a few days ago, and now that I've familiarized myself a bit more I was attempting to create my own error handler that I could use with all of my structs, sort of like an abstract class, but the example I got from the tutorial I saw has me a bit stumped.

Here is a small example I played with to test what the make function was doing. I kind of figured it out by tinkering, but I don't understand what it's actually doing, and why it is necessary.

type ErrorHandler struct {
    Errors map[string]string
}

type Form struct {
    ErrorHandler
}

func main() {
    form := &Form{}

    if true {
        fmt.Printf("%p\n", &form.Errors)
    } else {
        form.Errors = make(map[string]string)
        fmt.Printf("%p\n", &form.Errors)
    }
}

In the example above, I try changing the if statement from true to false to see if the memory address changes based on whether the make function is used or not and it stays the same both cases. I read the answer here and he said one of its uses is to "create a map with space preallocated" -- which honestly doesn't mean much to me since I'm new to pointers and all that, but the "create a map" part had me thinking it's like reinitializing that Errors map in the ErrorHandler struct, which would assign it to a new memory address, yes? But no, they stay the same.

So I tried creating a value in the map, once without the make function and once with the make function. The if condition gives me an error saying assignment to entry in nil map and goroutine [running], and the else statement prints "haha", which is what I set it to:

type ErrorHandler struct {
    Errors map[string]string
}

type Form struct {
    ErrorHandler
}

func main() {
    form := &Form{}

    if true {
        form.Errors["blah"] = "haha"
        fmt.Printf(form.Errors["blah"])
    } else {
        form.Errors = make(map[string]string)
        form.Errors["blah"] = "haha"
        fmt.Printf(form.Errors["blah"])
    }
}

So I sort of see what the make function is doing, but not exactly. As far as I can tell if I am going to "push" items into that map I need to use the make function, but I don't see why it's necessary. Why is the map[string]string set to nil in my struct because when I print it out I see "map[]" and not "nil"... that's confusing.

Can someone explain please? And how is this goroutine used here? Maybe that's the answer I'm looking for.. never used that before.

Also, since I have to use make, is there a way to kind of make it happen automatically instead of having to put it at the top of each method?

For example in my ErrorHandler struct I have a method that looks like this:

func (this *ErrorHandler) HandleErr(err string) {
    this.Errors = make(map[string]string)
    this.Errors["Error"] = err
}

and in my Form struct I also have another method that is validating the form, but also uses the `this.Errors = make(map[string]string) at the top of the method... feels non-DRY to me.

Any help is greatly appreciated.

Think of a map as a struct containing a pointer to the underling map structure and a size (there may be other stuff, not sure).

For example, think of it like:

struct Map {
  data *Entries
  size int
}

make, allocates the initial value of Entries according to the size passed to make (if any)

When you say:

form.Errors = make(map[string]string)

it's like saying:

form.Errors = struct { data : malloc(sizeof(Entries)*capacity), size : 0 }

which copies the "data" and "size" variables in to your form.Errors

The actual field "form.Errors" is still the same place in memory, the internal values of form.Errors have changed to match what make returned.

So, the address doesn't change when you look at &form.Errors

As for the nil error when pushing to a map you didn't make...

An un-maid map has no "data" segment yet, so you get a nil pointer error.

Not unlike doing:

var i *int
*i = 5

Also results in a nil error

Hopefully that all made sense and helps shed a bit of light on the confusion.

First, to answer your question:

from https://golang.org/pkg/builtin/#make

> The make built-in function allocates and initializes an object of type slice, map, or chan (only) [...]
>
> Map: An initial allocation is made according to the size but the
resulting map has length 0. The size may be omitted, in which case
a small starting size is allocated.

Secondly, there aren't goroutines in the code you posted.

Thirdly, make initializes the map and you probably shouldn't use it in every HandleErr call, because it would replace your current map. I think that what you want may be an initialization function like NewErrorHandler or NewForm. It is kind of make for your struct. For example:

func NewErrorHandler() ErrorHandler {
    return ErrorHandler{make(map[string]string)}
}

And finally why can't map initialize automatically? If it did you wouldn't have any control over initial size of your map. It may matter if you have mission critical code and you want it to be fast or low memory and know the size.

PS. There is also alternative way to initialize a map. If you want initialize an empty map you can write: map[string]string{}. If you want to create a map with initial values:

map[string]string{
    "a": "b",
    "c": "d",
}

So you could write you NewErrorHandler function like:

func NewErrorHandler() ErrorHandler {
    return ErrorHandler{map[string]string{}}
}