Having trouble understanding parts of the method.

I’m not sure if I’m 100% grasping your questions.

When I plug in

          let coordinatePoint = Point(x: 1, y: 1)
coordinatePoint.surroundingPoints()

The iterations DO change to values between 0-2 for both x and y. The results I get are

(x,y) = [{x 0, y 0}, {x 0, y 1}, {x 0, y 2}, {x 1, y 0}, {x 1, y 1}, {x 1, y 2}, {x 2, y 0}, {x 2, y 1}, {x 2, y 2}]

As to your question for this line of code

Why does it exist? When we have a similar line of code outside?

          let coordinatePoint = Point(x: 1, y: 1) 

We could make this this and it would still work

          let Awesome = Point(x: 1, y: 1)
Awesome.surroundingPoints() 

Remember not only is this line of code outside our for loop. It is also outside our struct. Remember everything in a struct is a blueprint.

Architects use blueprints as plans to create a building. In the same way coders use structs as plans to create an object.

So when we use the above line of code outside the struct we are creating an instance from our blueprint. The same way an architect creates a building from his blueprint.

AFTER we create an instance, we have something real to work with. Before that line of code all we have are plans.

In the code our struct “blueprint” is just saying. Here’s a plan to create an object with an x and y co-ordinate. When we do create that object here’s a plan (an instance method) to tell us some points that surround it.

Creating an object outside the blueprint is what’s called creating an instance.

So what does this line of code do?

          let coordinatePoint = Point(x: xCoord, y: yCoord)

Well it’s part of an instance method. A function is sequence of instructions that perform a very specific task packaged up as a unit. A method is any function that is associated with a particular type.

An instance method is one that can only be called once we have an actual instance.

So let’s say our architect has plans. He plans to build a building. After he builds the building he has instructions on how to figure out what other buildings surround his building.

We use our instance method on our metaphorical building to find what “buildings” or points surround it.

You can’t find buildings around a building that doesn’t exist.

That’s why we need an instance outside our blueprint.

Now the line of code while it looks similar, has nothing to do with the other line of code. It’s completely different. Again, we could make our code here with the constant coordinatePoint1A and it would still work.

struct Point {
    let x: Int
    let y: Int

    init(x: Int, y: Int) {
        self.x = x
        self.y = y
    }

    func surroundingPoints(withRange range: Int = 1) -> [Point]
        {
        var results: [Point] = []
        for xCoord in (x-range)...(x+range) {
                for yCoord in (y-range)...(y+range) {
                    let coordinatePoint1A = Point(x: xCoord, y: yCoord)
                    results.append(coordinatePoint1A)
                }

        }
        return results
    }
}
let coordinatePoint = Point(x: 1, y: 1)
coordinatePoint.surroundingPoints()

What this says is if we ever create a point, say (1,1) (which we do create later on in the example above). We will generate points around it by doing the following.

1. Our real “building” point (our instance) will give us x and y to be used. e.g. (x: 1, y: 1)
2. We take a range of 1 (withRange range: Int = 1)

3. with a point (1,1) xCoord is values of 0 to 2 as per xCoord in (x-range)...(x+range) (1-1) … (1+1)

4. then on each x value in the range we have y values of 0 to 2 for the same reason.

5. We create points each time assigned to a constant coordinatePoint1A ,

          let coordinatePoint1A = Point(x: xCoord, y: yCoord)
         results.append(coordinatePoint1A)

and during each iteration of the loop we append coordinatePoint1A to our results array we set up earlier in the instance method

 var results: [Point] = []

Again this only works on a real “building” that has co-ordinates. Before that all this is, is the method we will use. We make that building and figure out what surrounds it here

       let coordinatePoint = Point(x: 1, y: 1)
      coordinatePoint.surroundingPoints()

Again this is a confusing concept. Ask more questions if you need clarification.