## Welcome to the Treehouse Community

The Treehouse Community is a meeting place for developers, designers, and programmers of all backgrounds and skill levels to get support. Collaborate here on code errors or bugs that you need feedback on, or asking for an extra set of eyes on your latest project. Join thousands of Treehouse students and alumni in the community today. (Note: Only Treehouse students can comment or ask questions, but non-students are welcome to browse our conversations.)

### Looking to learn something new?

Treehouse offers a seven day free trial for new students. Get access to thousands of hours of content and a supportive community. Start your free trial today. # How can I make this code work?

How can I make this code work so that the slide function directly changes the potential properties of two objects? I tried inout parameters, but there was a lot of type confusion. I would really appreciate any sort of help.

```import CoreGraphics

protocol Moveable {
mutating func move(to point: CGPoint)
}

class Car: Moveable {
func move(to point: CGPoint) {} // changes some properties of the object e.g. x and y values
}

struct Ball: Moveable {
mutating func move(to point: CGPoint) {} // changes some properties of the object e.g. x and y values
}

var car = Car()
var ball = Ball()

func slide(_ thingToSlide: Moveable) {
let positionToSlideTo = CGPoint(x: 4, y: 6)
thingToSlide.move(to: positionToSlideTo) // error because the function parameter is immutable
}

slide(car)
slide(ball)
```

Hello,

An easy solution is to pass that parameter into a new variable:

```func slide(_ thingToSlide: Moveable) {
let positionToSlideTo = CGPoint(x: 4, y: 6)

var thingsToSlide = thingToSlide
thingsToSlide.move(to: positionToSlideTo) // error because the function parameter is immutable
}
```

if this is not what you are looking for let me know, we can go with more advance solution.

Good luck This works with Reference Types but with Value Types it doesn't. Perhaps more advanced solution that you mentioned will solve this problem.

```protocol Moveable {
mutating func move(to point: CGPoint)
}

class Car: Moveable {
var position: CGPoint
func move(to point: CGPoint) {
position.x = point.x
position.y = point.y
}

init(position: CGPoint) {
self.position = position
}
}

struct Ball: Moveable {
var position: CGPoint
mutating func move(to point: CGPoint) {
position.x = point.x
position.y = point.y
}
}

var car = Car(position: CGPoint(x: 2, y: 2))

var ball = Ball(position: CGPoint(x: 3, y: 4))

car.position // {x 2 y 2}
ball.position // {x 3 y 4}

func slide(_ thingToSlide: Moveable) {
let positionToSlideTo = CGPoint(x: 4, y: 6)
var a = thingToSlide
a.move(to: positionToSlideTo)
}

slide(car)
car.position // {x 4 y 6}
slide(ball)
ball.position // {x 3 y 4}
```

Correct,

I thought you wanted to fix the function's error.

In your case you may want to try something like this.

```var car = Car(position: CGPoint(x: 2, y: 2))
var ball = Ball(position: CGPoint(x: 3, y: 4))

car.position // {x 2 y 2}
ball.position // {x 3 y 4}

func slide(_ thingToSlide: Moveable, to position: CGPoint) -> Moveable {
var a = thingToSlide // Making the object mutable or a new copy
a.move(to: position) // Changing the objects position

return a // Returning the new object
}

car = slide(car, to: CGPoint(x: 7, y: 7) ) as! Car // Assigning the new car and casting it to its correct Object
car.position // {x 7 y 7}

ball = slide(ball, to:  CGPoint(x: 2, y: 2)) as! Ball // Assigning the new ball and casting it to its correct Object
ball.position // {x 2 y 2}
```

Hope this helps