Udostępnij za pośrednictwem

Krotki

Krotka to grupowanie nienazwanych, ale uporządkowanych wartości, prawdopodobnie różnych typów. Krotki mogą być typami referencyjnymi lub strukturami.

Składnia

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

Uwagi

Każdy element w poprzedniej składni może być dowolnym prawidłowym wyrażeniem języka F#.

Przykłady

Przykłady krotki obejmują pary, potrójne itd. z tego samego lub innego typu. Niektóre przykłady przedstawiono w poniższym kodzie.

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

Uzyskiwanie pojedynczych wartości

Do uzyskiwania dostępu i przypisywania nazw elementów krotki, jak pokazano w poniższym kodzie, można użyć dopasowania wzorca.

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

Możesz również dekonstruować krotkę za pomocą dopasowywania wzorca poza wyrażeniem match za pomocą let powiązania:

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

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

Możesz też dopasować wzorzec krotki jako dane wejściowe do funkcji:

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

Jeśli potrzebujesz tylko jednego elementu krotki, można użyć symbolu wieloznacznego (podkreślenia), aby uniknąć tworzenia nowej nazwy dla wartości, której nie potrzebujesz.

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

Kopiowanie elementów z krotki referencyjnej do krotki struktury jest również proste:

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

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

Funkcje fst i snd (tylko krotki referencyjne) zwracają pierwsze i drugie elementy krotki odpowiednio.

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

Nie ma wbudowanej funkcji, która zwraca trzeci element potrójny, ale można je łatwo napisać w następujący sposób.

let third (_, _, c) = c

Ogólnie rzecz biorąc, lepiej użyć dopasowania wzorca w celu uzyskania dostępu do poszczególnych elementów krotki.

Korzystanie z krotki

Krotki zapewniają wygodny sposób zwracania wielu wartości z funkcji, jak pokazano w poniższym przykładzie. Ten przykład wykonuje dzielenie całkowite i zwraca zaokrąglony wynik operacji jako pierwszy element członkowski pary krotki i resztę jako drugi element członkowski pary.

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

Krotki mogą być również używane jako argumenty funkcji, gdy chcesz uniknąć niejawnego currying argumentów funkcji, które są implikowane przez zwykłą składnię funkcji.

let sumNoCurry (a, b) = a + b

Zwykła składnia definiowania funkcji let sum a b = a + b umożliwia zdefiniowanie funkcji, która jest częściowym zastosowaniem pierwszego argumentu funkcji, jak pokazano w poniższym kodzie.

let sum a b = a + b

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

Używanie krotki jako parametru wyłącza currying. Aby uzyskać więcej informacji, zobacz "Częściowa aplikacja argumentów" w funkcjach.

Nazwy typów krotek

Podczas zapisywania nazwy typu, który jest krotką, należy użyć symbolu do oddzielenia * elementów. W przypadku krotki składającej intsię z elementu , , floati string, takiego jak (10, 10.0, "ten"), typ będzie zapisywany w następujący sposób.

int * float * string

Należy pamiętać, że nawiasy zewnętrzne są obowiązkowe podczas tworzenia aliasu typu dla typu krotki struktury.

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

Współdziałanie z krotkami języka C#

Krotki w języku C# są strukturami i są równoważne krotkom struktury w języku F#. Jeśli musisz współpracować z językiem C#, musisz użyć krotki struktury.

Jest to łatwe do zrobienia. Załóżmy na przykład, że musisz przekazać krotkę do klasy języka C#, a następnie użyć jej wyniku, co jest również krotką:

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

W kodzie języka F# możesz następnie przekazać krotkę struktury jako parametr i użyć wyniku jako krotki struktury.

open TupleInterop

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

Konwertowanie krotki referencyjnej i krotki struktury

Ponieważ krotki referencyjne i krotki struktury mają zupełnie inną podstawową reprezentację, nie są niejawnie konwertowane. Oznacza to, że kod, taki jak następujące, nie zostanie skompilowany:

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

Należy dopasować wzorzec na jednej krotki i skonstruować drugą z częściami składowymi. Na przykład:

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

Skompilowana forma krotki referencyjnej

W tej sekcji opisano formę krotki podczas ich kompilowania. Informacje przedstawione w tym miejscu nie są konieczne do odczytania, chyba że jest przeznaczony program .NET Framework 3.5 lub nowszy.

Krotki są kompilowane w obiekty jednego z kilku typów ogólnych, wszystkie o nazwie System.Tuple, które są przeciążone na arity lub liczba parametrów typu. Typy krotki są wyświetlane w tym formularzu podczas wyświetlania ich z innego języka, takiego jak C# lub Visual Basic, lub gdy używasz narzędzia, które nie zna konstrukcji języka F#. Typy Tuple zostały wprowadzone w programie .NET Framework 4. Jeśli używasz starszej wersji programu .NET Framework, kompilator używa wersji System.Tuple z wersji 2.0 biblioteki podstawowej języka F#. Typy w tej bibliotece są używane tylko dla aplikacji przeznaczonych dla wersji 2.0, 3.0 i 3.5 programu .NET Framework. Przekazywanie typów służy do zapewnienia zgodności binarnej między składnikami .NET Framework 2.0 i .NET Framework 4 F#.

Skompilowana forma krotki struktury

Krotki struktury (na przykład struct (x, y)), różnią się zasadniczo od krotki referencyjnej. Są one kompilowane w ValueTuple typie, przeciążone przez arity lub liczbę parametrów typu. Są one równoważne krotkom języka C# i krotkom języka Visual Basic oraz współpracy dwukierunkowej.

Zobacz też