Řazené kolekce členů

Článek
03/02/2024

Řazená kolekce členů je seskupení nepojmenovaných, ale seřazených hodnot, pravděpodobně různých typů. Řazené kolekce členů můžou být odkazové typy nebo struktury.

Syntaxe

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

Poznámky

Každý prvek v předchozí syntaxi může být libovolný platný výraz jazyka F#.

Příklady

Mezi příklady řazených kolekcí členů patří páry, trojité a tak dále, stejné nebo různé typy. Některé příklady jsou znázorněny v následujícím kódu.

(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)

Získání jednotlivých hodnot

Pomocí porovnávání vzorů můžete přistupovat k prvkům řazené kolekce členů a přiřazovat názvy, jak je znázorněno v následujícím kódu.

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

Dekonstrukci řazené kolekce členů můžete také dekonstruovat pomocí vzorů odpovídajících match mimo výraz prostřednictvím let vazby:

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

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

Nebo můžete vzorovat shodu u řazených kolekcí členů jako vstupy pro funkce:

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

Pokud potřebujete jenom jeden prvek řazené kolekce členů, můžete zástupný znak (podtržítko) použít, aby se zabránilo vytvoření nového názvu pro hodnotu, kterou nepotřebujete.

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

Kopírování prvků z referenční řazené kolekce členů do struktury řazené kolekce členů je také jednoduché:

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

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

fst Funkce a snd (pouze odkazování na řazené kolekce členů) vrátí první a druhý prvek řazené kolekce členů.

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

Neexistuje žádná integrovaná funkce, která vrací třetí prvek trojité hodnoty, ale můžete ji snadno napsat následujícím způsobem.

let third (_, _, c) = c

Obecně je lepší použít porovnávání vzorů pro přístup k jednotlivým prvkům řazené kolekce členů.

Použití řazených kolekcí členů

Řazené kolekce členů poskytují pohodlný způsob, jak vrátit více hodnot z funkce, jak je znázorněno v následujícím příkladu. Tento příklad provede celočíselné dělení a vrátí zaokrouhlený výsledek operace jako první člen páru řazené kolekce členů a zbytek jako druhý člen dvojice.

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

Řazené kolekce členů lze použít také jako argumenty funkce, pokud chcete zabránit implicitnímu kariování argumentů funkce, které jsou odvozeny obvyklou syntaxí funkce.

let sumNoCurry (a, b) = a + b

Obvyklá syntaxe pro definování funkce let sum a b = a + b umožňuje definovat funkci, která je částečnou aplikací prvního argumentu funkce, jak je znázorněno v následujícím kódu.

let sum a b = a + b

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

Použití řazené kolekce členů jako parametr zakáže kariing. Další informace naleznete v části Částečné použití argumentů ve funkcích.

Názvy typů řazené kolekce členů

Když napíšete název typu, který je řazenou kolekcí členů, použijete * symbol k oddělení prvků. Pro řazenou kolekci členů, která se skládá z int, floata , a , stringnapříklad (10, 10.0, "ten"), typ by byl zapsán následujícím způsobem.

int * float * string

Při vytváření aliasu typu pro strukturní řazenou kolekci členů jsou vnější závorky povinné.

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

Spolupráce s kolekcemi členů jazyka C#

Řazené kolekce členů v jazyce C# jsou struktury a jsou ekvivalentní strukturám řazených kolekcí členů v jazyce F#. Pokud potřebujete spolupracovat s jazykem C#, musíte použít řazené kolekce členů struktury.

To je snadné. Představte si například, že musíte předat řazenou kolekci členů do třídy jazyka C# a pak využít její výsledek, což je také řazená kolekce členů:

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

V kódu jazyka F# pak můžete předat řazenou kolekci členů struktury jako parametr a využít výsledek jako řazenou kolekci členů struktury.

open TupleInterop

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

Převod mezi referenčními kolekcemi členů a řazenou kolekcí členů struktury

Vzhledem k tomu, že referenční řazené kolekce členů a řazené řazené kolekce členů mají zcela jiné základní znázornění, nejsou implicitně konvertibilní. To znamená, že kód, například následující, se nezkompiluje:

// 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

Musí se shodovat s jednou řazenou řazenou kolekcí členů a vytvořit druhou s součástmi. Příklad:

// 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)

Kompilovaná forma referenčních kolekcí členů

Tato část vysvětluje tvar řazených kolekcí členů při kompilaci. Zde uvedené informace nejsou nutné číst, pokud necílili na rozhraní .NET Framework 3.5 nebo nižší.

Řazené kolekce členů jsou zkompilovány do objektů jednoho z několika obecných typů, všechny pojmenované System.Tuple, které jsou přetíženy na arity nebo počet parametrů typu. Typy řazené kolekce členů se zobrazí v tomto formuláři, když je zobrazíte z jiného jazyka, jako je C# nebo Visual Basic, nebo když používáte nástroj, který nezná konstrukty jazyka F#. Typy Tuple byly zavedeny v rozhraní .NET Framework 4. Pokud cílíte na starší verzi rozhraní .NET Framework, kompilátor používá verze System.Tuple z verze 2.0 základní knihovny F#. Typy v této knihovně se používají pouze pro aplikace, které cílí na verze 2.0, 3.0 a 3.5 rozhraní .NET Framework. Předávání typů se používá k zajištění binární kompatibility mezi komponentami .NET Framework 2.0 a .NET Framework 4 F#.

Kompilovaná forma řazených kolekcí členů struktury

Řazené kolekce členů struktury (například struct (x, y)) se zásadně liší od referenčních kolekcí členů. Jsou zkompilovány do ValueTuple typu, přetíženy arity nebo počtem parametrů typu. Jsou ekvivalentní kolekci členů jazyka C# a řazené kolekce členů jazyka Visual Basic a vzájemně interoperativně.

Sdílet prostřednictvím