Why create go types based on other?

what is the purpose of defining new types in go:

type NewType OldType

since NewType have only methods declarations, so:

var x NewType

can store also OldType 'objects'. Are there any advantages?

The reason behind naming types in general is fairly straightforward, and is much the same in most languages - being able to name complex types, like:

<!-- language: golang -->

type Person struct{
    name String
    age  uint8
}

However, naming a type like you described, which I'll call "type aliasing" (not sure if this is used by anyone else, but it's the term I tend to use), doesn't give you the above-mentioned advantage. What it <i>does</i> give you, however, is the ability to add methods to existing types. Go disallows you from adding methods to existing types that you did not define yourself (ie, built-in types or types defined in other packages), so aliasing allows you to pretend that you <i>did</i> define them yourself, and thus add methods to them. Another good way to think about it is like a much more concise version of creating a wrapper type (as you would in an OO language like Java, for example).

So, let's say that I wanted to be able use integers as errors. In Go, the error interface simply requires a method called "Error" which returns a string. Using type aliasing, I could do:

<!-- language: golang -->

type errorCode int

func (e errorCode) Error() string {
    return fmt.Sprintf("%d", e)
}

...and I could use integer error codes. By contrast, if I tried the following, I would get an error:

<!-- language: golang -->

func (e int) Error() string {
    return fmt.Sprintf("%d", e)
}

To demonstrate, check out this implementation:
http://play.golang.org/p/9NO6Lcdsbq

Just to clarify (because my use of the word "alias" may be misleading), two types which are otherwise equivalent (for example, int and errorCode in the above example) are not interchangeable. The Go type system treats them as fundamentally different types, although you may be able to type-cast between them.

> The Go Programming Language Specification
>
> Types
>
> A type determines the set of values and operations specific to values
> of that type.

You want identify a specific set of values and operations.

For example,

package main

import "fmt"

type Coordinate float64

type Point struct {
	x, y Coordinate
}

func (p *Point) Move(dx, dy Coordinate) {
	p.x += dx
	p.y += dy
}

func main() {
	var p = Point{3.14159, 2.718}
	fmt.Println(p)
	p.Move(-1, +1)
	fmt.Println(p)
}

Output:

{3.14159 2.718}
{2.14159 3.718}