Partager via


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<TKey, TValue>

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

Voir aussi

Référence

Microsoft.FSharp.Core, espace de noms (F#)