Condividi tramite


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

Vedere anche

Riferimenti

Spazio dei nomi Microsoft.FSharp.Core (F#)