Core.Operators, module (F#)
Opérateurs F# de base. Ce module est ouvert automatiquement dans l'intégralité du code F#.
Espace de noms/Chemin du module : Microsoft.FSharp.Core
Assembly : FSharp.Core (in FSharp.Core.dll)
[<AutoOpen>]
module Operators
Notes
Pour une vue d'ensemble des opérateurs dans F#, consultez Référence des symboles et opérateurs (F#).
Modules
Module |
Description |
|---|---|
module Checked |
Ce module contient les opérations arithmétiques de base avec les contrôles de dépassement. |
module OperatorIntrinsics |
Module de fonctions intrinsèques du compilateur permettant l'implémentation efficace de plages d'entiers F# et la réussite des appels dynamiques d'autres opérateurs F# |
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. |
Valeurs
Valeur |
Description |
|---|---|
( ! ) : 'T ref -> 'T |
Déréférence une cellule de référence mutable. |
( % ) : ^T1 -> ^T2 -> ^T3 |
Opérateur de modulo surchargé |
( &&& ) : ^T -> ^T -> ^T |
Opération de bits AND opérateur surchargé. |
( * ) : ^T1 -> ^T2 -> ^T3 |
Opérateur de multiplication surchargé |
( ** ) : ^T -> ^U -> ^T |
Opérateur surchargé d'élévation à la puissance. |
( + ) : ^T1 -> ^T2 -> ^T3 |
Opérateur d'addition surchargé |
( - ) : ^T1 -> ^T2 -> ^T3 |
Opérateur de soustraction surchargé |
( .. ) : ^T -> ^T -> seq<^T> |
L'opérateur de plage surchargé standard, par..exemple[n..m] pour les listes, seq {n..m} pour les séquences. |
( .. .. ) : ^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. |
( / ) : ^T1 -> ^T2 -> ^T3 |
Opérateur de division surchargé |
( := ) : 'T ref -> 'T -> unit |
Assigne à une cellule de référence mutable. |
( < ) : 'T -> 'T -> bool |
Comparaison structurelle d'infériorité |
( << ) : ('T2 -> 'T3) -> ('T1 -> 'T2) -> 'T1 -> 'T3 |
Compose deux fonctions, la fonction de droite étant appliquée en premier. |
( <<< ) : ^T -> int32 -> ^T |
Opérateur de décalage d'octet vers la gauche en fonction d'un nombre de bits spécifié |
( <= ) : 'T -> 'T -> bool |
Comparaison structurelle d'infériorité ou d'égalité |
( <> ) : 'T -> 'T -> bool |
Inégalité structurelle |
( <| ) : ('T -> 'U) -> 'T -> 'U |
Applique une fonction à une valeur, la valeur s'affichant à droite et la fonction à gauche. |
( <|| ) : ('T1 -> 'T2 -> 'U) -> 'T1 * 'T2 -> 'U |
Applique une fonction à deux valeurs, les valeurs s'affichant sous forme de paire à 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 |
Égalité structurelle. |
( > ) : 'T -> 'T -> bool |
Comparaison structurelle de supériorité |
( >= ) : 'T -> 'T -> bool |
Comparaison structurelle de supériorité ou d'égalité |
( >> ) : ('T1 -> 'T2) -> ('T2 -> 'T3) -> 'T1 -> 'T3 |
Compose deux fonctions, la fonction affichée à gauche s'appliquant en premier. |
( >>> ) : ^T -> int32 -> ^T |
Opérateur de décalage d'octet vers la droite en fonction d'un nombre de bits spécifié |
( @ ) : 'T list -> 'T list -> 'T list |
Concatène deux listes. |
( ^ ) : string -> string -> string |
Concatène deux chaînes. L'opérateur '+' peut également être utilisé. |
( ^^^ ) : ^T -> ^T -> ^T |
Au niveau de le bit surchargé opérateur de bits XOR. |
( |> ) : 'T1 -> ('T1 -> 'U) -> 'U |
Applique une fonction à une valeur, la valeur s'affichant à gauche et la fonction à droite. |
( ||> ) : 'T1 * 'T2 -> ('T1 -> 'T2 -> 'U) -> 'U |
Applique une fonction à deux valeurs, les valeurs s'affichant sous forme de paire à gauche et la fonction à droite. |
( ||| ) : ^T -> ^T -> ^T |
Opérateur de bits OR surchargé |
( |||> ) : '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 |
Opérateur prefix=plus surchargé |
( ~- ) : ^T -> ^T |
Négation unaire surchargée. |
( ~~~ ) : ^T -> ^T |
Opération de bits NOT opérateur surchargé. |
abs : ^T -> ^T |
Valeur absolue du nombre donné. |
acos : ^T -> ^T |
Cosinus inverse du nombre donné |
asin : ^T -> ^T |
Sinus inverse du nombre donné |
atan : ^T -> ^T |
Tangente inverse du nombre donné |
atan2 : ^T1 -> ^T2 -> 'T2 |
Tangente inverse de x/y où x et y sont spécifiés séparément |
box : 'T -> obj |
Effectue un boxing d'une valeur fortement typée. |
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. |
ceil : ^T -> ^T |
Valeur plafond du nombre donné. |
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. |
compare : 'T -> 'T -> int |
Comparaison générique. |
cos : ^T -> ^T |
Cosinus du nombre donné. |
cosh : ^T -> ^T |
Cosinus hyperbolique 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. |
decr : int ref -> unit |
Décrémente une cellule de référence mutable contenant un entier. |
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 |
enum : int32 -> ^U |
Convertit l'argument en un type enum particulier. |
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. |
exp : ^T -> ^T |
Exponentielle du nombre donné. |
Échec : string -> exn |
Génère un objet Exception. |
failwith : string -> 'T |
Lève une exception 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. |
float32 : ^T -> float32 |
Convertit l'argument en une valeur float 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. |
floor : ^T -> ^T |
Valeur plancher du nombre donné. |
fst : 'T1 * 'T2 -> 'T1 |
Retourne le premier élément d'un tuple, fst (a,b) = a. |
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. |
id : 'T -> 'T |
Fonction d'identité |
ignore : 'T -> unit |
Ignore la valeur passée. Cette fonction est souvent utilisée pour rejeter le résultat d'un calcul. |
incr : int ref -> unit |
Incrémente une cellule de référence mutable contenant un entier. |
infinity : float |
Équivalent à PositiveInfinity. |
infinityf : float32 |
É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. |
int16 : ^T -> int16 |
Convertit l'argument en entier signé 16 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. |
int64 : ^T -> int64 |
Convertit l'argument en entier signé 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. |
invalidArg : string -> string -> 'T |
Lève une exception ArgumentException. |
invalidOp : string -> 'T |
Lève une exception InvalidOperationException. |
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. |
verrouiller : 'Lock -> (unit -> 'T) -> 'T |
Exécute la fonction en tant que région d'exclusion mutuelle en utilisant la valeur d'entrée comme verrou. |
log : ^T -> ^T |
Logarithme naturel du nombre donné |
log10 : ^T -> ^T |
Logarithme de base 10 du nombre donné. |
max : 'T -> 'T -> 'T |
Maximum en fonction de la comparaison générique |
min : 'T -> 'T -> 'T |
Minimum en fonction de la comparaison générique |
nan : float |
Équivalent à NaN. |
nanf : float32 |
É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. |
not : bool -> bool |
Rend une valeur logique négative. |
nullArg : string -> 'T |
Lève une exception ArgumentNullException |
pown : ^T -> int -> ^T |
Opérateur de puissance surchargé. Si n > 0, alors il est équivalent à x*...*x pour n occurrences de x. |
raise : Exception -> 'T |
Lève une exception. |
ref : 'T -> 'T ref |
Crée une cellule de référence mutable. |
reraise : unit -> 'T |
Lève à nouveau une exception. Doit être utilisé uniquement lors de la gestion d'une exception |
round : ^T -> ^T |
Arrondit le nombre donné |
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. |
seq : seq<'T> -> seq<'T> |
Génère une séquence à l'aide de la syntaxe d'expression de séquence. |
sign : ^T -> int |
Signe du nombre donné |
sin : ^T -> ^T |
Sinus du nombre donné |
sinh : ^T -> ^T |
Sinus hyperbolique du nombre donné |
sizeof : int |
Retourne la taille interne d'un type, exprimée en octets. Par exemple, sizeof<int> retourne 4. |
snd : 'T1 * 'T2 -> 'T2 |
Retourne le deuxième élément d'un tuple, snd (a,b) = b. |
sqrt : ^T -> ^T |
Racine carrée du nombre donné. |
stderr : TextWriter |
Lit la valeur de la propriété Error. |
stdin : TextReader |
Lit la valeur de la propriété In. |
stdout : TextWriter |
Lit la valeur de la propriété Out. |
string : ^T -> string |
Convertit l'argument en une chaîne à l'aide de ToString. |
tan : ^T -> ^T |
Tangente du nombre donné |
tanh : ^T -> ^T |
Tangente hyperbolique du nombre donné |
truncate : ^T -> ^T |
Opérateur de troncation surchargé. |
typedefof : Type |
Générez une représentation de Type pour une définition de type. Si le type d'entrée est une instanciation de type générique, retourne la définition de type générique associée à tous les instanciations de ce type. |
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. |
uint16 : ^T -> uint16 |
Convertit l'argument en entier non signé 16 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. |
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. |
uint64 : ^T -> uint64 |
Convertit l'argument en entier non signé 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. |
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. |
unbox : obj -> 'T |
Effectue un unboxing d'une valeur fortement typée. C'est l'inverse de box, unbox<'T>(box<'T> a) égale à a. |
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é. |
Modèles actifs
Modèle actif |
Description |
|---|---|
( |Failure|_| ) : exn -> string option |
Correspond aux objets Exception dont le type au moment de l'exécution est précisément Exception. |
( |KeyValue| ) : KeyValuePair<'Key,'Value> -> 'Key * 'Value |
Modèle actif permettant de mettre en correspondance les valeurs de type KeyValuePair |
Plateformes
Windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2
Informations de version
Versions de bibliothèque principale F#
Prise en charge dans : 2,0, 4,0, portables