Use the const keyword instead. They can't take the := syntax.

Number constants have some magic to do with precision. They'll get the best precision possible at the time you use them.

bool, string, some number types (signed and unsigned; int, float and complex; different sizes), and runes.

A rune is a unicode code point. It effectively replaced char. Hooray, good choice.

Type(value) casts value to Type. All type conversions are explicit - missing type conversions are errors.

For example type MyInt uint8.

Pointers have type *SomeType. Get them using & and dereference them using *, just like in C.

You can't do any arithmetic on pointers in Go though.

The purpose of pointers in Go is to let a function mutate its arguments.

Pointers can also be useful to avoid copying large structs. By default, calling a function makes a copy.

Define a struct:

type SomeStructType struct {
    name SomeOtherType
    name2 SomeOtherType
}

To initialize a struct, pass it values for its fields in order SomeStructType{0, 0}.

Alternatively, you can name the fields SomeStructType{name: 0}.

Omitted fields will get the default zero value.

Then you can just access them with ..

Designed to be fast, but a bit more flexible than C.

Make an array by putting [arraySize] before a type, then write the initializer in braces {}. For example: [3]int{0, 1, 2}.

You can slice arrays using [] and :, for example: arr[start:end]. Slices are views onto arrays. You can modify the original through a slice though! Danger, Will Robinson!

You can leave out the start or end of a slice to get all of it in that direction.

If, when constructing an array, you omit the array size, then you will get a slice of that array instead.

You can re-slice a slice. As long as the underlying array is big enough, this is fine.

To see how long an array slice is, use the len function. To see how long its underlying array is, use the cap function.

You can use append to add elements to an array.

nil means an array slice with no backing array and no start or end.

Alternatively, it means a map with no keys and no backing array.

Are built in, because it's the new millenium after all.

Make them as:

map[keyType]valueType{
    key: value,
    key: value,
}

There's some special nice syntax where, if you're constructing types as your values, you can leave out their constructor name.

You insert things like most languages: m[key] = value.

Use delete: delete(m, key).

You retrieve elements and check for their presence with a two value assignment: value, hasKey = m[key]. If a value isn't present in the map, it's get the default zero value.

The make function does something to do with dynamic arrays. I need to read the article.

You can also use it make a map: make(map[keyType]ValueType). Not sure why you'd do this.

You can associate a function with a type: func (typeName Type) funcName (argName ArgType) (returnName ReturnType) {}.

This provides a dot syntax for invoking it on the type: Type{}.funcName(arg).

You can only define types in the package where that type was defined.

If a method takes a pointer type (called a pointer receiver), then it can modify the thing it was originally passed.

Pointer receivers can also dispatch on the value (dereferenced) version.

Interfaces declare some methods.

A type meets an interface which it has the methods for.

The empty interface type interface can hold any value.

You can get the original value back out of an interface variable: var t, isT = i.(T).

You can also switch on type. In each of the case statements, your variable will automatically get case to that type:

switch v := i.(type) {
    case T:
        return v
    default:
        return v
}

Some common interfaces are:

• Stringer
• Error
• io.Reader
• image.Image

Go provides defer to handle cleanup that always needs to happen regardless of errors.

You provide a function call to defer. That function call goes on a stack. At the end of the function you wrote defer in, Go executes the stack of deferred functions.

The function args are evaluated straightaway.

You can use defer to modify return values - this is commonly used for fiddling with error codes. This is possible because return values in Go have names, and defer happens after the return keyword.

This seems like a good opportunity for dark magic. It's interesting when you have a self-recursive function…

https://blog.golang.org/defer-panic-and-recover

Since we don't have exceptions, we need some other mechanism for when our program really has to die.

This is the panic keyword. Every function in the stack will execute its defer stack.

The counterpart to panic is recover(). This is only ever useful inside a deferred function. It returns nil if there is nothing to recover from.

Communicate between gorountines using channels. Make a channel with var ch = make(chan sometype bufferSize).

Send a value to channel with ch <- val. Get one out with:

val, channelOpen := <- ch

Reading a value from a channel blocks it.

A select statement is a bit like a switch statement where you provide multiple possible communication options (reads or writes to channels). It blocks and does the first one which becomes ready. You can provide a default case here, in which case it won't block, but will do the default case immediately if nothing is ready.

close() does the obvious. You don't have to use it. It may be helpful to communicate something though.

Inside a for loop: range works on a channel.