Implementing a Value Receiver for Data Transformation in Go

This challenge focuses on understanding and utilizing value receivers in Go. Value receivers create a copy of the struct being passed to a method, allowing modifications within the method to not affect the original struct. This is useful when you want to process data without altering the source.

Problem Description

You are tasked with creating a Point struct and a method Scale that scales the X and Y coordinates of a Point by a given factor. The Scale method should use a value receiver. This means that when Scale is called, a copy of the Point struct is created, and the scaling operation is performed on this copy. The original Point struct should remain unchanged.

What needs to be achieved:

• Define a Point struct with X and Y integer fields.
• Implement a Scale method for the Point struct that takes a float64 factor as input.
• The Scale method should multiply both the X and Y coordinates of the copy of the Point by the given factor.
• The Scale method should return the modified Point struct (the copy).

Key Requirements:

• The Scale method must use a value receiver.
• The original Point struct passed to Scale should not be modified.
• The returned Point struct should contain the scaled coordinates.

Expected Behavior:

When you call Scale on a Point struct, a copy of that struct is created. The X and Y coordinates of the copy are scaled by the factor. The original Point struct remains unchanged. The scaled Point struct is returned.

Edge Cases to Consider:

• Factor of 0: Should result in X and Y coordinates of 0.
• Negative factor: Should result in negative X and Y coordinates (if applicable).
• Large factor: Consider potential integer overflow, although this is not a primary focus of the challenge.

Examples

Example 1:

Input:
p := Point{X: 2, Y: 3}
scaledP := p.Scale(2.0)

Output:
scaledP: Point{X: 4, Y: 6}
p: Point{X: 2, Y: 3} // Original point remains unchanged

Explanation: A copy of p is created. The X and Y coordinates of the copy are multiplied by 2.0, resulting in Point{X: 4, Y: 6}. The original p remains Point{X: 2, Y: 3}.

Example 2:

Input:
p := Point{X: 5, Y: 5}
scaledP := p.Scale(-1.0)

Output:
scaledP: Point{X: -5, Y: -5}
p: Point{X: 5, Y: 5}

Explanation: A copy of p is created. The X and Y coordinates of the copy are multiplied by -1.0, resulting in Point{X: -5, Y: -5}. The original p remains Point{X: 5, Y: 5}.

Example 3: (Edge Case)

Input:
p := Point{X: 10, Y: 20}
scaledP := p.Scale(0.0)

Output:
scaledP: Point{X: 0, Y: 0}
p: Point{X: 10, Y: 20}

Explanation: A copy of p is created. The X and Y coordinates of the copy are multiplied by 0.0, resulting in Point{X: 0, Y: 0}. The original p remains Point{X: 10, Y: 20}.

Constraints

• The X and Y coordinates of the Point struct are integers.
• The scaling factor is a float64.
• The solution must be written in Go.
• The Scale method must use a value receiver.

Notes

• Remember that a value receiver creates a copy of the struct. Any modifications within the method will only affect the copy.
• Consider the implications of using a value receiver versus a pointer receiver in this scenario. This challenge specifically requires a value receiver.
• Focus on correctly implementing the scaling logic and ensuring the original struct is not modified.