learngo/09-go-type-system/questions/02-questions-defined-types.md

## Why you want to define new types?
1. To declare new methods
2. For type-safety
3. For readability and conveying meaning
4. All of the options above *CORRECT*

> **1-3:** Yes, that's only one of the reasons.
>


## Let's suppose that you've declared the following defined type. Which property below the new type doesn't get from its underlying type?

```go
// For example, let's say that you've defined a new type
// using time.Duration type like this:
type Millennium time.Duration
```
1. Methods *CORRECT*
2. Representation
3. Size
4. Range of values

> **1:** That's right. A defined type doesn't get its source type's methods.
>
> **2-4:** Actually the defined type gets it from its underlying type.
>


## How to define a new type using float32?
1. `var radius float32`
2. `radius = type float32`
3. `type radius float32` *CORRECT*
4. `type radius = float32`

> **1-2:** This is not a correct syntax.
>
> **3:** `radius` is a new type, defined using `float32`.
>
> **4:** This declares `radius` as an alias to `float32`. So, they become the same types.
>


## How to fix the following code?
```go
type Distance int

var (
    village Distance = 50
    city = 100
)

fmt.Print(village + city)
```
1. `int(village + city)`
2. `village + int(city)`
3. `village(int) + city`
4. `village + Distance(city)` *CORRECT*

> **1-3:** There's a type mismatch in this code. But, this won't fix it.
>
> **4:** That's right. Now, the `city`'s type is Distance in the expression.
>


## For the following program which types you might want to declare?
```go
package main
import "fmt"

func main() {
	celsius := 35.
	fahrenheit := (9*celsius + 160) / 5
	fmt.Printf("%g ºC is %g ºF\n", celsius, fahrenheit)
}
```

1. Celsius and Fahrenheit using int64
2. Celsius and Fahrenheit using float64 *CORRECT*
3. Temperature using int64
4. Temperature using uint32

> **1:** But a degree value has a floating part. So, using an integer may not the best way.
>
> **2:** float64 can represent a degree value.
>
> **3-4:** But a degree value has a floating part. So, using an integer may not the best way. Also, there are two different temperature units here: Celsius and Fahrenheit. Isn't it better to create two distinct types?
>


## What's the underlying type of the Millennium type?
```go
type (
    Duration int64
    Century Duration
    Millennium Century
)
```
1. `int64` *CORRECT*
2. `Duration`
3. `Century`
4. Another type

> **1:** That's right. Go's type system is flat. So, the defined type's underlying type is a type with a real structure. int64 is not just a name, it has its own structure, it's a predeclared type.
>
> **2:** Duration is just a new type name. It doesn't have its own structure.
>
> **3:** Century is just a new type name. It doesn't have its own structure.
>


## Which types do not need to be converted between each other?
**HINT:** Aliased types do not require type conversion.

1. byte and uint8 *CORRECT*
2. byte and rune
3. rune and uint8
4. byte and uint32

> **1:** byte data type is an alias to uint8 data type. So, they don't need conversion between each other. They're the same types.
>


## Which types do not need to be converted between each other?
**HINT:** Aliased types do not require type conversion.

1. byte and uint32
2. byte and rune
3. rune and int32 *CORRECT*
4. byte and int8

> **3:** rune data type is an alias to int32 data type. So, they don't need conversion between each other. They're the same types.
>