Core.Operators, module (F#)

module Checked

Ce module contient les opérations arithmétiques de base avec les contrôles de dépassement.

module Unchecked

Ce module contient les opérations de base qui n'appliquent pas de contrôles au moment de l'exécution et/ou statiques.

( ! ) : 'T ref -> 'T

Déréférence une cellule de référence mutable.

( &&& ) : ^T -> ^T -> ^T

Opération de bits AND opérateur surchargé.

( ** ) : ^T -> ^U -> ^T

Opérateur surchargé d'élévation à la puissance.

( - ) : ^T1 -> ^T2 -> ^T3

Opérateur de soustraction surchargé

( .. .. ) : ^T -> ^Step -> ^T -> seq<^T>

L'opérateur de plage de saut surchargé standard, par..exemple[n..skip..m] pour les listes, seq {n..skip..m} pour les séquences.

( := ) : 'T ref -> 'T -> unit

Assigne à une cellule de référence mutable.

( << ) : ('T2 -> 'T3) -> ('T1 -> 'T2) -> 'T1 -> 'T3

Compose deux fonctions, la fonction de droite étant appliquée en premier.

( <= ) : 'T -> 'T -> bool

Comparaison structurelle d'infériorité ou d'égalité

( <| ) : ('T -> 'U) -> 'T -> 'U

Applique une fonction à une valeur, la valeur s'affichant à droite et la fonction à gauche.

( <||| ) : ('T1 -> 'T2 -> 'T3 -> 'U) -> 'T1 * 'T2 * 'T3 -> 'U

Applique une fonction à trois valeurs, les valeurs s'affichant sous forme de triple à droite et la fonction à gauche.

( > ) : 'T -> 'T -> bool

Comparaison structurelle de supériorité

( >> ) : ('T1 -> 'T2) -> ('T2 -> 'T3) -> 'T1 -> 'T3

Compose deux fonctions, la fonction affichée à gauche s'appliquant en premier.

( @ ) : 'T list -> 'T list -> 'T list

Concatène deux listes.

( ^^^ ) : ^T -> ^T -> ^T

Au niveau de le bit surchargé opérateur de bits XOR.

( ||> ) : 'T1 * 'T2 -> ('T1 -> 'T2 -> 'U) -> 'U

Applique une fonction à deux valeurs, les valeurs s'affichant sous forme de paire à gauche et la fonction à droite.

( |||> ) : 'T1 * 'T2 * 'T3 -> ('T1 -> 'T2 -> 'T3 -> 'U) -> 'U

Applique une fonction à trois valeurs, les valeurs s'affichant sous forme de triple à gauche et la fonction à droite.

( ~- ) : ^T -> ^T

Négation unaire surchargée.

abs : ^T -> ^T

Valeur absolue du nombre donné.

asin : ^T -> ^T

Sinus inverse du nombre donné

atan2 : ^T1 -> ^T2 -> 'T2

Tangente inverse de x/y où x et y sont spécifiés séparément

byte : ^T -> byte

Convertit l'argument en octet. Il s'agit d'une conversion directe pour tous les types numériques primitifs. Pour les chaînes, l'entrée est convertie à l'aide de Parse avec les paramètres InvariantCulture. Sinon, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

char : ^T -> char

Convertit l'argument en caractère. Les entrées numériques sont converties en fonction de l'encodage UTF-16 des caractères. Les entrées de chaîne doivent contenir exactement un caractère. Pour d'autres types d'entrées, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

cos : ^T -> ^T

Cosinus du nombre donné.

decimal : ^T -> decimal

Convertit l'argument en Decimal à l'aide d'une conversion directe pour tous les types numériques primitifs. Pour les chaînes, l'entrée est convertie à l'aide de Parse avec les paramètres InvariantCulture. Sinon, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

defaultArg : 'T option -> 'T -> 'T

Utilisée pour spécifier une valeur par défaut pour un argument facultatif dans l'implémentation d'une fonction

sortie : int -> 'T

Arrête le processus isolé du matériel actuel, si les paramètres de sécurité le permettent ; sinon, lève une exception. appelle Exit.

Échec : string -> exn

Génère un objet Exception.

float : ^T -> float

Convertit l'argument en une valeur float 64 bits. Il s'agit d'une conversion directe pour tous les types numériques primitifs. Pour les chaînes, l'entrée est convertie à l'aide de Parse avec les paramètres InvariantCulture. Sinon, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

floor : ^T -> ^T

Valeur plancher du nombre donné.

hash : 'T -> int

Fonction de hachage générique, conçue pour retourner des valeurs de hachage égales pour les éléments égaux selon l'opérateur =. Par défaut, elle utilise le hachage structurel pour les types d'union, d'enregistrement et de tuple F# afin de hacher le contenu intégral du type. Le comportement exact de la fonction peut être ajusté selon chaque type en implémentant GetHashCode pour chaque type.

ignore : 'T -> unit

Ignore la valeur passée. Cette fonction est souvent utilisée pour rejeter le résultat d'un calcul.

infinity : float

Équivalent à PositiveInfinity.

int : ^T -> int

Convertit l'argument en entier signé 32 bits. Il s'agit d'une conversion directe pour tous les types numériques primitifs. Pour les chaînes, l'entrée est convertie à l'aide de Parse avec les paramètres InvariantCulture. Sinon, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

int32 : ^T -> int32

Convertit l'argument en entier signé 32 bits. Il s'agit d'une conversion directe pour tous les types numériques primitifs. Pour les chaînes, l'entrée est convertie à l'aide de Parse) avec les paramètres InvariantCulture. Sinon, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

invalidArg : string -> string -> 'T

Lève une exception ArgumentException.

limitedHash : int -> 'T -> int

Fonction de hachage générique. Cette fonction a le même comportement que hash, mais le hachage structurel par défaut pour les types d'union, d'enregistrement et de tuple F# s'arrête lorsque le nombre limite de nœuds est atteint. Le comportement exact de la fonction peut être ajusté selon chaque type en implémentant GetHashCode pour chaque type.

log : ^T -> ^T

Logarithme naturel du nombre donné

max : 'T -> 'T -> 'T

Maximum en fonction de la comparaison générique

nan : float

Équivalent à NaN.

nativeint : ^T -> nativeint

Convertit l'argument en entier natif signé. Il s'agit d'une conversion directe pour tous les types numériques primitifs. Sinon, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

nullArg : string -> 'T

Lève une exception ArgumentNullException

raise : Exception -> 'T

Lève une exception.

reraise : unit -> 'T

Lève à nouveau une exception. Doit être utilisé uniquement lors de la gestion d'une exception

sbyte : ^T -> sbyte

Convertit l'argument en octet signé. Il s'agit d'une conversion directe pour tous les types numériques primitifs. Pour les chaînes, l'entrée est convertie à l'aide de Parse avec les paramètres InvariantCulture. Sinon, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

sign : ^T -> int

Signe du nombre donné

sinh : ^T -> ^T

Sinus hyperbolique du nombre donné

snd : 'T1 * 'T2 -> 'T2

Retourne le deuxième élément d'un tuple, snd (a,b) = b.

stderr : TextWriter

Lit la valeur de la propriété Error.

stdout : TextWriter

Lit la valeur de la propriété Out.

tan : ^T -> ^T

Tangente du nombre donné

truncate : ^T -> ^T

Opérateur de troncation surchargé.

typeof : Type

Générez une représentation d'exécution Type de type statique. Le type statique est conservé sur la valeur retournée.

uint32 : ^T -> uint32

Convertit l'argument en entier non signé 32 bits. Il s'agit d'une conversion directe pour tous les types numériques primitifs. Pour les chaînes, l'entrée est convertie à l'aide de Parse avec les paramètres InvariantCulture. Sinon, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

unativeint : ^T -> nativeint

Convertit l'argument en entier natif non signé à l'aide d'une conversion directe pour tous les types numériques primitifs. Sinon, l'opération nécessite une méthode de conversion statique appropriée sur le type d'entrée.

using : 'T -> ('T -> 'U) -> 'U

Nettoie les ressources associées à l'objet en entrée après l'achèvement de la fonction donnée. Le nettoyage se produit même quand une exception est levée par le code protégé.

( |Failure|_| ) : exn -> string option

Correspond aux objets Exception dont le type au moment de l'exécution est précisément Exception.