Item openen

Q# ondersteunt itemtoegang voor matrixitems en voor items in door de gebruiker gedefinieerde typen. In beide gevallen is de toegang alleen-lezen; de waarde kan niet worden gewijzigd zonder een nieuw exemplaar te maken met behulp van een copy-and-update-expressie.

Toegang tot matrixitems en matrixsegmentering

Bij een matrixexpressie en een expressie van het type Int of Rangekan een nieuwe expressie worden gevormd met behulp van [ de operator voor toegang tot matrixitems die bestaat uit en ].

Als de expressie tussen de haakjes van het type Intis, bevat de nieuwe expressie het matrixitem op die index. Als arr bijvoorbeeld van het type Double[] is en vijf of meer items bevat, is dat arr[4] een expressie van het type Double.

Als de expressie tussen de haakjes van het type Rangeis, bevat de nieuwe expressie een matrix van alle items die zijn geïndexeerd door de opgegeven Range. Als de Range leeg is, is de resulterende matrix leeg. Bijvoorbeeld:

let arr = [10, 11, 36, 49];
let ten = arr[0]; // contains the value 10
let odds = arr[1..2..4]; // contains the value [11, 49]
let reverse = arr[...-1...]; // contains the value [49, 36, 11, 10]

In de laatste regel van het voorbeeld zijn de begin- en eindwaarde van het bereik voor het gemak weggelaten. Zie Contextuele expressies voor meer informatie.

Als de matrixexpressie geen eenvoudige id is, moet deze tussen haakjes worden geplaatst om een item of een segment te extraheren. Als arr1 en arr2 bijvoorbeeld beide matrices van gehele getallen zijn, wordt een item uit de samenvoeging uitgedrukt als (arr1 + arr2)[13]. Zie Prioriteit en associativiteit voor meer informatie.

Alle matrices in Q# zijn op nul gebaseerd. Het eerste element van een matrix arr is dus altijd arr[0]. Er wordt een uitzondering opgetreden tijdens runtime als de index of een van de indexen die wordt gebruikt voor segmentering buiten de grenzen van de matrix valt, bijvoorbeeld als deze kleiner is dan nul of groter of gelijk is aan de lengte van de matrix.

Itemtoegang voor door de gebruiker gedefinieerde typen

(Zie Typedeclaraties voor meer informatie over het definiëren van aangepaste typen met een of meer benoemde of anonieme items).

De ingesloten items kunnen worden geopend via hun naam of door deconstructie, geïllustreerd door de volgende instructies die kunnen worden gebruikt als onderdeel van een bewerking of functie-implementatie:

    let complex = Complex(1., 0.); // create a value of type Complex
    let (re, _) = complex!;       // item access via deconstruction
    let im = complex::Imaginary;  // item access via name

De operator voor itemtoegang (::) haalt benoemde items op, zoals wordt geïllustreerd in het volgende voorbeeld:

newtype TwoStrings = (str1 : String, str2 : String);

operation LinkTwoStrings(str : TwoStrings) : String {
    let s1 = str::str1;
    let s2 = str::str2;
    return s1 + s2;
}

Hoewel benoemde items toegankelijk zijn via hun naam of via deconstructie, zijn anonieme items alleen toegankelijk voor de laatste. Aangezien deconstructie afhankelijk is van alle ingesloten items, wordt het gebruik van anonieme items afgeraden wanneer deze items moeten worden geopend buiten de compilatie-eenheid waarin het type is gedefinieerd.

Toegang via deconstructie maakt gebruik van de uitpakoperator (!). De operator voor uitpakken retourneert een tuple van alle ingesloten items, waarbij de vorm van de tuple overeenkomt met de vorm die is gedefinieerd in de declaratie en één item-tuple gelijk is aan het item zelf (zie deze sectie).

Bijvoorbeeld voor een waarde nested van het type Nested die als volgt is gedefinieerd

newtype Nested = (Double, (ItemName : Int, String));

de expressie nested! retourneert een waarde van het type (Double, (Int, String)).

De ! operator heeft een lagere prioriteit dan beide operatoren voor itemtoegang, maar hogere prioriteit dan elke andere operator. Zie Prioriteit en associativiteit voor een volledige lijst met prioriteiten.