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 |
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