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 |
Oggetto di 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
Value |
Oggetto di descrizione |
---|---|
( ! ) : 'T ref -> 'T |
Dereferenzia una cella di riferimento modificabile. |
( % ) : ^T1 -> ^T2 -> ^T3 |
Operatore modulo di overload. |
( &&& ) : ^T -> ^T -> ^T |
Operatore AND logico 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 skip dell'intervallo di overload standard, 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 XOR logico di overload. |
( |> ) : '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 logico 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 logico 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. Rappresenta 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. Rappresenta 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 |
Consente di convertire l'argomento in un numero float a 32 bit. Rappresenta 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 Signed Integer a 32 bit. Rappresenta 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 |
Consente di convertire l'argomento in un Integer con segno a 16 bit. Rappresenta 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 |
Consente di convertire l'argomento in un Integer con segno a 32 bit. Rappresenta 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 |
Consente di convertire l'argomento in un Integer con segno a 64 bit. Rappresenta 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. |
lock : '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. Rappresenta 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. Rappresenta 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. Rappresenta 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. Rappresenta 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 |
Consente di convertire l'argomento in un Integer senza segno a 64 bit. Rappresenta 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 7, Windows Vista SP2, Windows XP SP3, Windows XP x64 SP2, Windows Server 2008 R2, Windows Server 2008 SP2, Windows Server 2003 SP2
Informazioni sulla versione
F# Runtime
Supportato in: 2.0, 4.0
Silverlight
Supportato in: 3