How to change x,y coordinates in a class - f#

Question

I have an assignment, where I have made to classes, "Drone" and "Airspace".
I need to move the x,y coordinates of all the drones that exists, which I have stored in x.drones in the Airspace class, as a list. However I am having trouble accessing and manipulating the list in x.drones. How can I in a class change the values of a list from another member?
I have given all my code so far down under, it's the method x.flyDrones I need help with.
I have tried to make a for loop, but that doesn't seem to work.
module Drones
type Drone(x1:int, y1:int, x2:int, y2:int, spd:int) =
static let mutable count = 0
static let mutable hinsta = []
let mutable position = (x1,y1)
let mutable destination = (x2,y2)
let mutable speed = spd
do count <-count + 1
let mutable insta = [x1,y1,x2,y2,spd]
do hinsta <- hinsta # insta
static member Count = count
static member Collection = hinsta
member x.fly =
if fst destination - fst position > 0 then position <- (x1+1,y1)
else if snd destination - snd position > 0 then position <- (x1,y1+1)
member x.isFinished =
fst destination - fst position = 0 && snd destination - snd position = 0
type Airspace =
member x.drones = Drone.Collection
member x.droneDist(drone1, drone2) =
let dist = ((fst drone1 - fst drone2),(snd drone1 - snd drone2))
dist
member x.flyDrones =
for drone in x.drones do
member x.addDrone(x1, y1, x2, y2, spd) = new Drone(x1, y1, x2, y2, spd)
//member x.willCollide(time) =

Answer 1

Sorry to disappoint you, OliverVS, but this ain't gonna fly. I believe I can see your intentions, but this needs a complete rewrite rather than a fix. Let me try to give you some advice.
First of all, why do you use classes at all? I wouldn't, but I'll assume the assignment says you should, so let's continue doing that.
The Drone class should be responsible for keeping the information for a single drone, but you have x.drones in Airspace that is set to Drone.Collection, which is not a collection or a list of Drone, but rather a list of int*int*int*int*int that is kept as a static list in the Drone class. That's really messy. Why do the Drone class have statics? The Airspace class should be responsible for keeping a list of Drone, so get rid of all the statics in Drone, and instead find a way to maintain the list of drones in the Airspace class.
The Airspace type has instance members - not static members - yet there is no constructor. You will likely want a default constructor, so it should be Airspace() =, and then you need to instantiate a single Airspace.
You don't need to maintain a count when you can simply find the count of drones by getting the length of the list of drones.
You can solve the entire assignment without using a single static anywhere.
Start member names with capital letter.
Members like x.fly and x.flyDrones are not methods, because they don't have arguments. You need at least the () argument for them to be methods.
x.addDrone correctly creates a new Drone, but it should add it to the list of drones that the Airspace class should have.
The Drone class uses tuples for position and destination, which leads to considerably less readable code with use of fst and snd throughout. Don't do that. In general, use records instead of tuples if the tuples cause confusion. Don't use mysterious names like x1, y1, x2, y2, spd, insta, hinsta, fly.
A few changes will make the Drone class a little better, though I haven't followed all of my own advice here. The point of shadowing the class arguments with mutables of the same name, is 1) indeed that they are mutable which means they can be changed, and 2) block further use of the original arguments, which avoids confusion of any sort, whether it's while writing code or reading code.
type Drone(x1:int, y1:int, x2:int, y2:int, speed:int) =
let mutable x1 = x1
let mutable y1 = y1
let mutable x2 = x2
let mutable y2 = y2
let mutable speed = speed
member _.X1 = x1
member _.Y1 = y1
member _.X2 = x2
member _.Y2 = y2
member _.Speed = speed
member _.Fly() =
if x2 - x1 > 0 then x1 <- x1 + 1
elif y2 - y1 > 0 then y1 <- y1 + 1
member _.IsFinished = x2 - x1 = 0 && y2 - y1 = 0