Rekordok

A rekord a névtelen, de rendezett értékek csoportosítása, esetleg különböző típusúak. A tuples lehet referenciatípus vagy struktúra.

Syntax

(element, ... , element)
struct(element, ... ,element )

Megjegyzések

Az előző szintaxis minden eleme bármilyen érvényes F#-kifejezés lehet.

Példák

Ilyenek például az azonos vagy különböző típusú párok, triplák és így tovább. Néhány példát az alábbi kód szemléltet.

(1, 2)

// Triple of strings.
("one", "two", "three")

// Tuple of generic types.
(a, b)

// Tuple that has mixed types.
("one", 1, 2.0)

// Tuple of integer expressions.
(a + 1, b + 1)

// Struct Tuple of floats
struct (1.025f, 1.5f)

Egyéni értékek beolvasása

Mintamegfeleltetés használatával elérheti és hozzárendelheti a rekordelemek nevét az alábbi kódban látható módon.

let print tuple1 =
   match tuple1 with
    | (a, b) -> printfn "Pair %A %A" a b

A rekordokat a kifejezésen kívüli match mintaegyeztetésen keresztül is dekonstruálhatja kötéssel let :

let (a, b) = (1, 2)

// Or as a struct
let struct (c, d) = struct (1, 2)

De a függvények bemeneteként is mintaegyeztethető a uplesen:

let getDistance ((x1,y1): float*float) ((x2,y2): float*float) =
    // Note the ability to work on individual elements
    (x1*x2 - y1*y2) 
    |> abs 
    |> sqrt

Ha a rekordnak csak egy elemére van szüksége, a helyettesítő karakter (az aláhúzás) használatával elkerülheti, hogy új nevet hozzon létre egy olyan értékhez, amelyekre nincs szüksége.

let (a, _) = (1, 2)

Az elemek másolása egy referencia-rekordból egy szerkezetbe is egyszerű:

// Create a reference tuple
let (a, b) = (1, 2)

// Construct a struct tuple from it
let struct (c, d) = struct (a, b)

A függvények fst és snd (csak hivatkozási rekordok) a rekord első és második elemeit adja vissza.

let c = fst (1, 2)
let d = snd (1, 2)

Nincs olyan beépített függvény, amely visszaadja a tripla harmadik elemét, de könnyen megírhat egyet az alábbiak szerint.

let third (_, _, c) = c

Általában jobb, ha mintamegfeleltetést használunk az egyes elemek eléréséhez.

A Tuples használata

A Tuples kényelmes módot kínál több érték visszaadására egy függvényből, ahogy az az alábbi példában is látható. Ez a példa egész osztást hajt végre, és a művelet lekerekített eredményét adja vissza egy rekordpár első tagjaként, a többit pedig a pár második tagjaként.

let divRem a b =
   let x = a / b
   let y = a % b
   (x, y)

A függvényargumentumok függvényargumentumként is használhatók, ha el szeretné kerülni a függvényargumentumok implicit beszűkítését, amelyet a szokásos függvényszintaxis feltételez.

let sumNoCurry (a, b) = a + b

A függvény let sum a b = a + b meghatározásának szokásos szintaxisa lehetővé teszi, hogy olyan függvényt definiáljon, amely a függvény első argumentumának részleges alkalmazása, ahogyan az az alábbi kódban is látható.

let sum a b = a + b

let addTen = sum 10
let result = addTen 95
// Result is 105.

Ha a paraméter egy rekordot használ, az letiltja a curry-használatot. További információ: "Argumentumok részleges alkalmazása" a Functionsben.

A rekordtípusok nevei

Ha egy rekordtípus nevét írja ki, a szimbólummal elválaszthatja az * elemeket. Egy , egy floatés egystring, például (10, 10.0, "ten")egyből álló intrekord esetében a típus az alábbiak szerint lesz megírva.

int * float * string

Vegye figyelembe, hogy a külső zárójelek kötelezőek a típus aliasának létrehozásakor a struct tuple típushoz.

type TupleAlias = string * float
type StructTupleAlias = (struct (string * float))

Együttműködés a C# Tuples használatával

A C#-beli csuplok szerkezetek, és egyenértékűek az F#-ban található strukturált vonásokkal. Ha a C#-tal kell együttműködnie, strukturált uplokat kell használnia.

Ez egyszerűen elvégezhető. Tegyük fel például, hogy át kell adnia egy rekordot egy C#-osztálynak, majd fel kell használnia annak eredményét, ami szintén rekord:

namespace CSharpTupleInterop
{
    public static class Example
    {
        public static (int, int) AddOneToXAndY((int x, int y) a) =>
            (a.x + 1, a.y + 1);
    }
}

Az F#-kódban ezután átadhat egy struct tuple-t paraméterként, és az eredményt strukturálási rekordként használhatja fel.

open TupleInterop

let struct (newX, newY) = Example.AddOneToXAndY(struct (1, 2))
// newX is now 2, and newY is now 3

Konvertálás referencia- és strukturálási tuplesek között

Mivel a Referencia-tuples és a Struct Tuples teljesen eltérő mögöttes ábrázolású, nem implicit módon konvertálhatók. Vagyis az alábbi kód nem fordítható le:

// Will not compile!
let (a, b) = struct (1, 2)

// Will not compile!
let struct (c, d) = (1, 2)

// Won't compile!
let f(t: struct(int*int)): int*int = t

A mintázatnak egyeznie kell az egyik elemet, és létre kell készítenie a másikat az összetevőkkel. Példa:

// Pattern match on the result.
let (a, b) = (1, 2)

// Construct a new tuple from the parts you pattern matched on.
let struct (c, d) = struct (a, b)

Lefordított referencia-tuples

Ez a szakasz a fordításukkor megjelenő uplesek formáját ismerteti. Az itt található információk nem szükségesek az olvasáshoz, hacsak nem a 3,5-ös vagy alacsonyabb .NET-keretrendszer célba.

A rekordokat a rendszer több általános típus egyikének objektumaiba állítja össze, amelyek mindegyike neve System.Tupletúlterhelt az aritáson, vagy a típusparaméterek száma. A rekordtípusok akkor jelennek meg ebben az űrlapban, ha más nyelvről( például C# vagy Visual Basic) tekinti meg őket, vagy ha olyan eszközt használ, amely nem ismeri az F#-szerkezeteket. A Tuple típusokat a 4. .NET-keretrendszer vezettük be. Ha a .NET-keretrendszer egy korábbi verzióját célozza meg, a fordító az F# Core Library 2.0-s verziójának verzióit System.Tuple használja. A kódtárban szereplő típusok csak olyan alkalmazásokhoz használhatók, amelyek a .NET-keretrendszer 2.0-s, 3.0-s és 3.5-ös verzióját célják. A típustovábbítás a 2.0 .NET-keretrendszer és .NET-keretrendszer 4 F# összetevő közötti bináris kompatibilitás biztosítására szolgál.

A Struct Tuples lefordított formája

A strukturált tuplok (például struct (x, y)) alapvetően eltérnek a referencia-csuploktól. Ezek a ValueTuple típusba vannak lefordítva, túlterhelve az aritás vagy a típusparaméterek száma alapján. Ezek egyenértékűek a C# Tuples és a Visual Basic Tuples értékével, és kétirányúan működnek együtt.

Lásd még

• F# nyelvi referencia
• F#-típusok