Make your own data type using structures and gain the ability to model everyday objects in code.

Structures

_Instances_ are how we create individual objects using a structure. In the previous exercise's example, we created a structure to model dogs:

```swift
struct Dog {
  var age = 0
  var isGood = true
}
```

In `Dog`, we've modeled some general traits dogs have. However, each dog is unique in their own way &mdash; to represent this programmatically, we have to create different instances of dogs! 

```swift
var eloise = Dog()
```

In the example above we've created a single instance of the `Dog` struct by adding parentheses `()` to `Dog` and save it to the `eloise` variable. 


Creating an Instance

In the previous exercise, we've explicitly provided an `init()` method inside our struct. Structures also come with a built-in _memberwise initializer_ that can be used to assign values upon instance creation. So in certain cases, we don't actually need to use `init()`! 

Let's remove the `init()` method from `Dog` and take a look our code again:

```swift
struct Dog {
  var age: Int
  var isGood: Bool
}
```


Using the memberwise initializer, we can create another instance:
```swift
var eloise = Dog(age: 5, isGood: true)
```

Notice that we didn't need an `init()` method to provide initial values &mdash; but, we still have to provide arguments for all the initial values! It's still important that we pass in the arguments in the order that matches the ordering of the properties in the `Dog` structure. 


While it's harder for other developers to know exactly what our code means without an `init()` method (decreased _readability_), we now have a convenient means of initializing instances. Another positive is that it's great if we don't need to manipulate the provided argument(s). 


Memberwise Initialization

Now that we know how to create a structure we should also know how to create customized instances of that structure. But, what if we're creating a lot of instances, do we really need to customize every single instance? In some cases, we might find that that instance's properties don't always need a unique value and that we can reuse some common values.

We'll use Swift's concept of _default property values_ to set values for properties inside our structures. This will save us time later on once we get to creating instances. 

```swift
struct Dog {
  var age = 0
  var isGood = true
}
```

Notice that the syntax for assigning default values is identical to assigning values to variables. Later, when we create an instance of `Dog`, that instance's `age` value will automatically be `0` and  `isGood`'s value `true`. This concept might save us time later on since all dogs are good (🐶), and they're 0 years old right after birth.

As another example, let's look back at our [introductory structures GIF](https://content.codecademy.com/courses/learn-swift/structures/house_structures.gif), we'll see that our building blueprint has default property values: two floors and a triangular roof. As we created new building instances, we kept some values and changed others. 



Default Property Values

We've created models of real-life objects using instances and now let's find out how to customize them. Since instances of a struct can have different property values, we should know how to access these values. In Swift, we use _dot syntax_ to do just that:

```pseudo 
instance.property
```

This might look familiar from other exercises like trying to find `.count` of a collection type. That's because `.count` is also a property, that's right we've used properties before! 

Let's turn back to our trusty `Dog` structure:

```swift
struct Dog {
  var age = 0
  var isGood = true
}

var bucket = Dog()
```

Notice that we added a `Dog` instance, `bucket` who still has the structure's default properties and values. To check `bucket`'s properties, we use dot syntax as mentioned earlier:

```swift
print(bucket.age)    // Prints: 0
print(bucket.isGood) // Prints: true
``` 

Awesome, we were able to access property values! We can also reassign properties using the assignment operator (`=`). Suppose `bucket` is 7 years old and he is being a bad boy, we can reassign the values, like so:

```swift
bucket.age = 7
bucket.isGood = false
```



Accessing and Editing Properties

In addition to the `init()` method, we can also provide our structs with custom methods that instances can call. These _instance methods_ are created like a normal function but within the scope of the structure itself:

```swift
struct Dog {
  var age : Int
  var isGood : Bool

  init(age: Int, isGood: Bool) {
    self.age = age
    self.isGood = isGood
  }
  
  // We've added a bark() method:
  func bark() {
    print("woof")
  }
}
```

In the example above, we added a method `bark()` using the `func` keyword &mdash; it doesn't have any parameters, nor does it return anything. Although the method syntax looks exactly like a function, the major difference is that a [method is specific to the structure's instances](https://docs.swift.org/swift-book/LanguageGuide/Methods.html). 

Great, now we can create an instance of `Dog` that has the `.bark()` method: 

```swift
var bucket = Dog(age: 4, isGood: true)
bucket.bark() // Prints: woof
```

After we defined our instance, `bucket`, we can call the method using dot syntax and a pair of parentheses after the method name.

Structure Methods

In Swift, data types can be _value_ types or _reference_ types. This means that different data types are stored and accessed in different ways. Structures are value types, this means every time an instance is created or copied, the instance has its own set of unique values. We'll cover reference types in a separate lesson. 

For example:
```swift
var youngDog = Dog(age: 5, isGood: true)
var oldDog = youngDog
oldDog.age = 10

print(oldDog.age)   // Prints: 10
print(youngDog.age) // Prints: 5
```

There are some nuances that we should go over from the example above. 
* First we created `youngDog`, an instance of `Dog`, that was initialized with the properties: `age: 5` and `isGood: true`. 
* Immediately afterward, we create another variable `oldDog` that has the value of `youngDog`. 
* We assign the `age` of `oldDog` a value of `10`, but we left `youngDog` alone. 
* When we print `oldDog.age` it prints `10`.
* When we print `youngDog.age` it prints `5`. 🤔

We may have thought that since we changed `oldDog.age` that it would also affect `youngDog` since `oldDog` was copied from `youngDog`. But remember and go back to our main point structs are value types. When we created `oldDog` using `youngDog`,  `oldDog` is only storing the _values_ of `youngDog`. The takeaway here is that: any changes we make to an instance of a structure, like `oldDog`, it's properties will not affect other instances. 


Structures are Value Types

With structures, we can create our own data type and use them to model everyday objects with their own unique characteristics. Here's the basic syntax for a structure:

```pseudo
struct Name {
  Properties
}
```

The `struct` keyword followed by the name of the structure creates the structure. By convention, this name is capitalized. Then inside the curly braces that follow is the body and where _properties_ and _methods_ (which we'll explore in a later exercise) unique to the structure are defined. 

Here's an example of a `struct` that models a dog: 

```swift
struct Dog {
  var age: Int
  var isGood: Bool
}
```

Structures tend to have singular names, hence `Dog` instead of `Dogs`. When we look closer at the `Dog` structure, we see it has two properties which look like typed variables:
* `age` typed as `Int`.
* `isGood` typed as `Bool`. 

Creating a Structure

In the previous exercises, we've done a lot with structures: we've created a structure, made instances, and added properties and methods, etc.  So just take a second to pause and consider our achievement &mdash; we modeled a real-life object in our code! In doing so, we also made a new data type in our program!  

Let's take a quick look back at our example:

```swift
struct Dog {
  var age = 0
  var isGood = true
}

var eloise = Dog()
```

We can use Swift's built-in function `type(of:)` function and check what is `eloise`'s type: 

```swift
type(of: eloise) // Dog
```  

That's right, `eloise` is a `Dog` type. Remember, we can also set an explicit type for our variables. Let's say we have another dog named `bucket`:

```swift
var bucket: Dog = Dog()
```

Notice that we can specify `bucket`'s type as `Dog`. This means we can also use structures inside other structures as property values:

```swift
struct Pets {
  var petDog: Dog
  var petCat: Cat
}
```

Above, we created another structure `Pets` that helps us keep track of our pets. For the `petDog` property, we typed it as `Dog`. We also added another property `petCat` for when we make a `Cat` structure. With the ability to create new types, it opens the door for us to model more complex real-life objects! 


New Type

In the previous exercise, we've supplied our instances' properties with default values. However, if we know that our struct instances vary a lot from one to another, we can include an `init()` method for customization. The following syntax is used for an `init()` method:

```pseudo
struct SampleStruct {
  var structProperty: Type
  init (structProperty: Type) {
     self.structProperty = structProperty
  }
}
```

Since _methods_ are essentially [functions specific to a type](https://docs.swift.org/swift-book/LanguageGuide/Methods.html) (in this case, the type is a structure), the syntax looks a lot like functions. The `init()` method is special since it doesn't require the `func` keyword and gets called upon instance creation. Like functions, methods can have parameters but don't need to have any. Another unique feature is that the `init()` method uses the `self` keyword to reference itself. Let's see `init()` in action:

```swift
struct Dog {
  var age : Int
  var isGood : Bool

  init (age: Int, isGood: Bool) {
    self.age = age
    self.isGood = isGood
  }
}

// Using the init() method:
var bucket = Dog(age: 4, isGood: true)
print(bucket.age)    // Prints: 4
print(bucket.isGood) // Prints: true
```

In `Dog`'s `init()` method, we set parameters for `Dog`'s properties. Inside the method, we assign `self.age` and `self.isGood` their respective values. When we create `bucket`, an instance of `Dog`, we have to pass into the parentheses the arguments needed to assign values to `bucket`'s properties. From our `print()` statements we've confirmed that `bucket`'s properties were assigned correctly. 


The Init Method

Wonderful job, we've successfully created our own data type using structures and modeled dogs, books, and birds in our code!

In this lesson, we covered:
* Structures are a means of modeling real-life objects programmatically. 
* How to create a structure using the `struct` keyword along with properties and methods. 
* Structure properties are used to describe the characteristics and values of the structure. 
* To model individual objects, we can create instances of `struct`s, which may have unique property values. 
* We can access and edit properties using dot notation. 
* If we know that most of our instances will have a specific property value, we can assign default property values inside the struct.
* Using the `init()` method allows us to provide an instance with specific values for the structure's given properties. 
* Even without an `init()` method, structs come with a default memberwise initialization method that can assign values to declared properties inside a struct. 
* Structures can have methods that are functions accessible to their instances. 
* Structures are value types, any copied struct that has its properties altered will not affect the original structure from which it was copied. 

🙌❗


Review

While a _mutating method_ may sound like a term out of a mad scientist's lab, it's actually how we change an instance's properties using an instance method. To do so, we need the `mutating` keyword:

```swift
struct Dog {
  var age : Int
  var isGood : Bool

  init(age: Int, isGood: Bool) {
    self.age = age
    self.isGood = isGood
  }

  // birthday() is a mutating method:
  mutating func birthday() -> Int {
    print("Best doggy")
    self.age += 1
    return self.age
  }
}

```

In our `Dog` structure, we used the `mutating` keyword to add the mutating method `birthday()`. This method prints out `"Best doggy"`, is also able to affect `self` &mdash; note how we can increment `self.age`. In the end, the method returns `self.age`. 

Let's take a look at when we call the method on our `Dog` instance, `bucket`:

```swift
var bucket = Dog(age: 7, isGood: true)
var newAge = bucket.birthday() 
// Prints: Best doggy

print(newAge) // Prints: 8
```
Above, our method worked as expected: 
* `Best doggy` printed out.
* We were able to save the return value of `bucket.birthday()` to `newAge`.
* Printing out `newAge` showed that `bucket`'s age increased by `1`!

If we tried to use a regular method to change a property, without the `mutating` keyword, like so:

```swift
func birthday() -> Int {
  print("Best doggy")
  self.age += 1
  return self.age
}
```

Calling `bucket.birthday()` Swift's compiler would raise an error.

```error
error: left side of mutating operator isn't mutable: 'self' is immutable
note: mark method 'mutating' to make 'self' mutable
```

This error lets us know that we can't reassign a value for `self`. The note then tells us to use the `mutating` keyword to allow the method to reassign `self`.

Mutating Methods

As developers, we create programs and applications to solve problems &mdash; problems that we encounter on a daily basis that usually stem from everyday life. More often than not, these problems are complex. 

Wouldn't it be nice if we had some sort of data type that would help us model this complexity of everyday life? That way we wouldn't have to solely rely on basic data types like `String`s, `Int`s, or some collection of these types like arrays, sets, or dictionaries; this data type would combine all these facets and allow us to closely mimic real-world objects. 

We don't have to wonder about this hypothetical situation! That's what the structure data type, also known as a struct, is for! 

With structures, we can create blueprints of everyday objects and use this blueprint to make specific instances of these objects directly in our program. 

Let's imagine that we are building an app and we need to store some user information such as:
* Username
* Email
* Their bio 

We could make a user structure that serves as the blueprint when creating individual users. Each individual user is an _instance_ of the blueprint but they would still contain their own unique values. 

This idea of a blueprint structure provides customization and programmatically allows us to create as many different users as we want. Essentially, we were able to take a complex object like a user and represent them in code!

In this lesson, we'll learn how to create these structures and how to customize them to suit them to our needs. 🏗️


GIF showing how the blueprint of a house is used as a structure to make other houses of varying heights. 