Modulo Core.Operators (F#)
Operatori F# di base.Questo modulo viene aperto automaticamente in ogni codice F#.
Percorso spazio dei nomi/modulo: Microsoft.FSharp.Core
Assembly: FSharp.Core (in FSharp.Core.dll)
[<AutoOpen>]
module Operators
Note
Per una panoramica degli operatori in F#, vedere Riferimenti per simboli e operatori (F#).
Moduli
Modulo |
Descrizione |
|---|---|
modulo Checked |
Questo modulo contiene le operazioni aritmetiche di base con controlli di overflow. |
modulo OperatorIntrinsics |
Un modulo contenente funzioni intrinseche del compilatore per realizzare implementazioni efficienti di intervalli di interi F# e chiamate dinamiche di altri operatori F# |
modulo Unchecked |
Questo modulo contiene operazioni di base che non applicano controlli di runtime e/o statici |
Valori
Valore |
Descrizione |
|---|---|
( ! ) : 'T ref -> 'T |
Dereferenzia una cella di riferimento modificabile. |
( % ) : ^T1 -> ^T2 -> ^T3 |
Operatore modulo di overload. |
( &&& ) : ^T -> ^T -> ^T |
Operatore AND bit per bit di overload. |
( * ) : ^T1 -> ^T2 -> ^T3 |
Operatore di moltiplicazione di overload. |
( ** ) : ^T -> ^U -> ^T |
Operatore di elevazione a potenza di overload. |
( + ) : ^T1 -> ^T2 -> ^T3 |
Operatore di addizione di overload. |
( - ) : ^T1 -> ^T2 -> ^T3 |
Operatore di sottrazione di overload. |
( .. ) : ^T -> ^T -> seq<^T> |
Operatore di intervallo standard di overload, ad..esempio[n..m] per gli elenchi, seq {n..m} per le sequenze. |
( .. .. ) : ^T -> ^Step -> ^T -> seq<^T> |
Operatore di intervallo di visualizzazione standard di overload, ad..esempio[n..skip..m] per gli elenchi, seq {n..skip..m} per le sequenze. |
( / ) : ^T1 -> ^T2 -> ^T3 |
Operatore di divisione di overload. |
( := ) : 'T ref -> 'T -> unit |
Assegna a una cella di riferimento modificabile. |
( < ) : 'T -> 'T -> bool |
Confronto strutturale minore di. |
( << ) : ('T2 -> 'T3) -> ('T1 -> 'T2) -> 'T1 -> 'T3 |
Consente di combinare due funzioni, di cui la funzione sulla destra viene applicata per prima. |
( <<< ) : ^T -> int32 -> ^T |
Operatore di spostamento a sinistra di un numero specificato di bit su byte, di overload. |
( <= ) : 'T -> 'T -> bool |
Operatore di confronto strutturale minore o uguale a. |
( <> ) : 'T -> 'T -> bool |
Operatore di disuguaglianza strutturale. |
( <| ) : ('T -> 'U) -> 'T -> 'U |
Applica una funzione a un valore, con il valore a destra e la funzione a sinistra. |
( <|| ) : ('T1 -> 'T2 -> 'U) -> 'T1 * 'T2 -> 'U |
Applica una funzione a due valori, con la coppia di valori a destra e la funzione a sinistra. |
( <||| ) : ('T1 -> 'T2 -> 'T3 -> 'U) -> 'T1 * 'T2 * 'T3 -> 'U |
Applica una funzione a tre valori, con il gruppo di tre valori a destra e la funzione a sinistra. |
( = ) : 'T -> 'T -> bool |
Operatore di uguaglianza strutturale. |
( > ) : 'T -> 'T -> bool |
Operatore strutturale maggiore di. |
( >= ) : 'T -> 'T -> bool |
Operatore strutturale maggiore o uguale a. |
( >> ) : ('T1 -> 'T2) -> ('T2 -> 'T3) -> 'T1 -> 'T3 |
Consente di combinare due funzioni, di cui la funzione sulla sinistra viene applicata per prima. |
( >>> ) : ^T -> int32 -> ^T |
Operatore di overload di spostamento a destra di un numero specificato di bit su byte. |
( @ ) : 'T list -> 'T list -> 'T list |
Concatena due elenchi. |
( ^ ) : string -> string -> string |
Concatena due stringhe.È inoltre possibile utilizzare l'operatore '+'. |
( ^^^ ) : ^T -> ^T -> ^T |
Operatore bit per bit di overload XOR. |
( |> ) : 'T1 -> ('T1 -> 'U) -> 'U |
Applica una funzione a un valore, con il valore a sinistra e la funzione a destra. |
( ||> ) : 'T1 * 'T2 -> ('T1 -> 'T2 -> 'U) -> 'U |
Applica una funzione a due valori, con la coppia di valori a sinistra e la funzione a destra. |
( ||| ) : ^T -> ^T -> ^T |
Operatore OR bit di overload |
( |||> ) : 'T1 * 'T2 * 'T3 -> ('T1 -> 'T2 -> 'T3 -> 'U) -> 'U |
Applica una funzione a tre valori, con il gruppo di tre valori a sinistra e la funzione a destra. |
( ~+ ) : ^T -> ^T |
Operatore prefix plus di overload. |
( ~- ) : ^T -> ^T |
Operatore unario di negazione di overload. |
( ~~~ ) : ^T -> ^T |
Operatore NOT bit per bit di overload. |
abs : ^T -> ^T |
Restituisce il valore assoluto del numero specificato. |
acos : ^T -> ^T |
Coseno inverso del numero specificato. |
asin : ^T -> ^T |
Seno inverso del numero specificato. |
atan : ^T -> ^T |
Tangente inversa del numero specificato. |
atan2 : ^T1 -> ^T2 -> 'T2 |
Tangente inversa di x/y, in cui x e y vengono specificati separatamente. |
box : 'T -> obj |
Esegue il boxing di un valore fortemente tipizzato. |
byte : ^T -> byte |
Consente di convertire l'argomento in un byte.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
ceil : ^T -> ^T |
Restituisce il numero intero più piccolo che risulta maggiore del valore specificato. |
char : ^T -> char |
Consente di convertire l'argomento in un carattere.I valori numerici di input vengono convertiti sulla base della codifica UTF-16 per i caratteri.Le stringhe di input devono avere una lunghezza esatta di un carattere.Per altri tipi di input, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
compare : 'T -> 'T -> int |
Operazione di confronto generico. |
cos : ^T -> ^T |
Restituisce il coseno del numero specificato. |
cosh : ^T -> ^T |
Coseno iperbolico del numero specificato. |
decimal : ^T -> decimal |
Consente di convertire l'argomento in Decimal utilizzando una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
decr : int ref -> unit |
Decrementa una cella di riferimento modificabile che contiene un Integer. |
defaultArg : 'T option -> 'T -> 'T |
Operatore utilizzato per specificare un valore predefinito per un argomento facoltativo nell'implementazione di una funzione. |
enum : int32 -> ^U |
Consente di convertire l'argomento in un tipo enum particolare. |
chiudere : int -> 'T |
Consente di uscire dal processo hardware isolato corrente, se le impostazioni di sicurezza lo consentono. In caso contrario, genera un'eccezione.Chiama Exit. |
exp : ^T -> ^T |
Valore esponenziale del numero specificato. |
Errore : string -> exn |
Compila un oggetto Exception. |
failwith : string -> 'T |
Genera un'eccezione Exception. |
float : ^T -> float |
Consente di convertire l'argomento in un numero float a 64 bit.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
float32 : ^T -> float32 |
Converte l'argomento in un float a 32 bit.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
floor : ^T -> ^T |
Numero intero minore del numero specificato. |
fst : 'T1 * 'T2 -> 'T1 |
Restituisce il primo elemento di una tupla, fst (a,b) = a. |
hash : 'T -> int |
Una funzione hash generica, progettata per restituire valori hash uguali per elementi che risultano uguali in base all'operatore =.Per impostazione predefinita, la funzione utilizzerà l'algoritmo di hash strutturale per i tipi F# unione, record e tupla, eseguendo l'hashing del contenuto completo del tipo.È possibile regolare il comportamento esatto della funzione tipo per tipo implementando la funzione GetHashCode per ogni tipo. |
id : 'T -> 'T |
La funzione di identità. |
ignore : 'T -> unit |
Ignora il valore passato.Questo operatore viene spesso utilizzato per eliminare i risultati di un calcolo. |
incr : int ref -> unit |
Incrementa una cella di riferimento modificabile che contiene un integer. |
Infinity : float |
Equivalente a PositiveInfinity.. |
infinityf : float32 |
Equivalente a PositiveInfinity.. |
int : ^T -> int |
Converte l'argomento in un numero intero con segno a 32 bit.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
int16 : ^T -> int16 |
Converte l'argomento in un numero intero con segno a 16 bit.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
int32 : ^T -> int32 |
Converte l'argomento in un numero intero con segno a 32 bit.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse) con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
int64 : ^T -> int64 |
Converte l'argomento in un numero intero con segno a 64 bit.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
invalidArg : string -> string -> 'T |
Genera un'eccezione ArgumentException. |
invalidOp : string -> 'T |
Genera un'eccezione InvalidOperationException. |
limitedHash : int -> 'T -> int |
Funzione hash generica.Questa funzione ha un comportamento analogo alla funzione hash, tuttavia l'esecuzione dell'algoritmo di hash strutturale predefinito per i tipi F# di unione, record e tupla si arresta quando viene raggiunto il limite specificato di nodi.È possibile regolare il comportamento esatto della funzione tipo per tipo implementando la funzione GetHashCode per ogni tipo. |
blocco : 'Lock -> (unit -> 'T) -> 'T |
Esegue la funzione come una regione a esclusione reciproca utilizzando il valore di input come blocco. |
log : ^T -> ^T |
Restituisce il logaritmo naturale del numero specificato. |
log10 : ^T -> ^T |
Restituisce il logaritmo in base 10 del numero specificato. |
max : 'T -> 'T -> 'T |
Valore massimo sulla base di un confronto generico. |
min : 'T -> 'T -> 'T |
Restituisce il valore minimo sulla base di un confronto generico. |
nan : float |
Equivalente a NaN.. |
nanf : float32 |
Equivalente a NaN.. |
nativeint : ^T -> nativeint |
Consente di convertire l'argomento in un Signed Integer nativo.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
not : bool -> bool |
Negazione di un valore logico. |
NullArg : string -> 'T |
Genera un'eccezione ArgumentNullException. |
pown : ^T -> int -> ^T |
Operatore di elevazione a potenza di overload.Se n > 0 equivale a x*...*x per n occorrenze di x. |
raise : Exception -> 'T |
Genera un'eccezione. |
ref : 'T -> 'T ref |
Crea una cella di riferimento modificabile. |
reraise : unit -> 'T |
Genera di nuovo un'eccezione.Questo operatore deve essere utilizzato solo nella gestione di un'eccezione. |
round : ^T -> ^T |
Arrotonda il numero specificato. |
sbyte : ^T -> sbyte |
Converte l'argomento in byte con segno.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
seq : seq<'T> -> seq<'T> |
Compila una sequenza utilizzando la sintassi dell'espressione di sequenza. |
sign : ^T -> int |
Restituisce il segno del numero specificato. |
sin : ^T -> ^T |
Restituisce il seno del numero specificato. |
sinh : ^T -> ^T |
Seno iperbolico del numero specificato. |
sizeof : int |
Restituisce la dimensione interna di un tipo, in byte.Ad esempio, sizeof<int> restituisce 4. |
snd : 'T1 * 'T2 -> 'T2 |
Restituisce il secondo elemento di una tupla, snd (a,b) = b. |
sqrt : ^T -> ^T |
Radice quadrata del numero specificato. |
stderr : TextWriter |
Legge il valore della proprietà Error. |
stdin : TextReader |
Legge il valore della proprietà In. |
stdout : TextWriter |
Legge il valore della proprietà Out. |
string : ^T -> string |
Converte l'argomento in una stringa mediante ToString. |
tan : ^T -> ^T |
Tangente del numero specificato. |
tanh : ^T -> ^T |
Tangente iperbolica del numero specificato. |
truncate : ^T -> ^T |
Operatore truncate di overload. |
typedefof : Type |
Genera una rappresentazione Type per una definizione di tipo.Se il tipo ricevuto in input è una creazione di istanza di tipo generico restituisce la definizione di tipo generico associata a tutte le creazioni di istanze analoghe. |
typeof : Type |
Genera una rappresentazione Type di runtime di un tipo statico.Il tipo statico viene tuttavia conservato nel valore restituito. |
uint16 : ^T -> uint16 |
Consente di convertire l'argomento in un Integer senza segno a 16 bit.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
uint32 : ^T -> uint32 |
Consente di convertire l'argomento in un Integer senza segno a 32 bit.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
uint64 : ^T -> uint64 |
Converte l'argomento in Unsigned Integer a 64 bit.Si tratta di una conversione diretta per tutti i tipi numerici primitivi.Per le stringhe, l'input viene convertito mediante Parse con impostazioni InvariantCulture.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
unativeint : ^T -> nativeint |
Consente di convertire l'argomento in un Integer nativo senza segno utilizzando una conversione diretta per tutti i tipi numerici primitivi.Altrimenti, l'operazione richiede l'applicazione di un metodo di conversione statico appropriato per il tipo di input. |
unbox : obj -> 'T |
Esegue la conversione unboxing di un valore fortemente tipizzato.Questa è l'operazione inversa di box, unbox<'T>(box<'T> a) uguale a a. |
using : 'T -> ('T -> 'U) -> 'U |
Libera le risorse associate all'oggetto di input dopo il completamento della funzione specificata.L'operazione di pulizia viene eseguita anche quando il codice protetto genera un'eccezione. |
Criteri attivi
Criterio attivo |
Descrizione |
|---|---|
( |Failure|_| ) : exn -> string option |
Corrisponde a oggetti Exception il cui tipo di runtime è esattamente Exception. |
( |KeyValue| ) : KeyValuePair<'Key,'Value> -> 'Key * 'Value |
Criterio attivo per eseguire la corrispondenza di valori di tipo KeyValuePair<TKey, TValue> |
Piattaforme
Windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2
Informazioni sulla versione
Versioni della libreria di base F#
Supportato in: 2,0, 4,0, portabile