Struct for dybdekurver i sjø-kartene

stemmer
0

Jeg prøver å gjøre en struct i F # for å representere dybdekurver i et kart havet. Det må inneholde en liste av koordinater og en flottør fortelle hvilken dybde er representert (f.eks. 4,5 m). Jeg har gjort det på denne måten:

type Coord =
    struct
        val X : float
        val Y : float
        new(x,y) = { X = x ; Y = y }
    end

type DepthCurve =
    struct
        val Coords : list<Coord>
        val Depth  : float
        new(list_of_Coords, depth) = { Coords = list_of_Coords ; Depth = depth}
    end

let myCoord1 = new Coord(1.,2.)
let myCoord2 = new Coord(3.,4.)
let myDepthCurve = new DepthCurve([myCoord1;myCoord2] , 5. )

Problemet mitt er at dette ikke la meg lage Polygon og dens coords på en gang, som dette:

let myDepthCurve = {coords=[[1.;2.];[3.;4.]] , 5}

Det eksisterer en løsning på dette:

type Coord  = { X : float; Y : float }
type 'a DepthCurve = {coords: 'a list;}
let myDepthCurve = {coords=[[1.;2.];[3.;4.]]};;

men det trenger ikke la meg få dybde indikerer flyter i struct også, og det gjør ikke la meg begrense typer listen for å være bare coords.

Hvordan kan jeg kombinere det beste vet fra begge verdener?

Publisert på 24/07/2009 klokken 10:37
kilden bruker
På andre språk...                            


3 svar

stemmer
1

Objekttyper du har laget er standard .NET-strukturer med en konstruktør - De har ikke den spesielle F # -posten-initialisering sytnax ( { ... }).

For problemet ditt, kan du bare skrive litt wrapper funksjon:

let curve depth coords = New DepthCurve([for (x, y) in coords -> New Coord(x, y)], depth)

brukt som dette

let testCurve = curve 10. [(1., 2.); (3., 4.); ...]

Når erklære strukturer i den forkortede posten syntaks, bør du gjøre det slik:

type Coord = float * float // Type-alias for a 2D-float-tuple
type DepthCurve = { coords : Coord list; depth : float }

let myCurve = { coords = [(1., 2.); ...], depth = 42. }

Det er ingen grunn til at du bør bruke en generisk liste, bare angi Coord list(som betyr List of Coords). Og vær oppmerksom på forskjellen mellom en liste ( [1; 2; 3]) og en tuppel ( (1, 2, 3)). De sistnevnte er mye mer egnet for å representere coords.

Vennligst ta en titt på denne artikkelen på F # strukturer og typer.

Svarte 24/07/2009 kl. 10:47
kilden bruker

stemmer
0

Svaret avhenger av måten du konstruere programmet.

For tilfelle du activly bruke funksjonelle paradigmet (ingen mutasjon, høy-ordens funksjoner, mønstergjenkjenning) Jeg stemmer for tre valg:

(* tuple with type constractor and any getters you need: *)
let makeCoord x y = (x,y)
let makeCurve depth coords = (depth,coords)
let addCurveCoord (depth,coords) coord = (depth, coord::coords)
let getCurveDepth (depth,_) = depth
let getCurveCoords (_,coords) = coords
let getFirstCurveCoord (_,coords) = List.hd coords
//...

(* or types described by Dario *)
(* or tagged unions for case you need specific access to parts of your data *)

for tilfelle du foretrekker OOP du kan lage enkle objekt hierarki.

Den største fordelen med FP er enkel modifisering av design på ethvert trinn i programmet constraction. Men selvfølgelig, det koster å din ved eksplisitte statlige argumenter. Men kan slå dem ved monadisk uttrykk :)

Svarte 24/07/2009 kl. 13:27
kilden bruker

stemmer
-1

Til Dario:

Når jeg skriver dette i VS 2008:

type Coord = float * float // Type-alias for a 2D-float-tuple
type DepthCurve = { coords : Coord list; depth : float }

let myCurve = { coords = [(1., 2.); (3., 4.)], depth = 42. }

Jeg får theese feil:

This expression has type  'a * 'b but is here used with type  Coord list
no assignment given for field 'depth'
Svarte 24/07/2009 kl. 22:32
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more