Compartilhar via


Módulo de Core.Operators (F#)

Operadores básicos de F#.Este módulo é aberta automaticamente em todo o código de F#.

Namespace/Module Path: Microsoft.FSharp.Core

Assembly: FSharp.Core (em FSharp.Core.dll)

[<AutoOpen>]
module Operators

Comentários

Para obter uma visão geral dos operadores em F#, consulte Símbolo e o referência de operador (F#).

Módulos

Module

Descrição

módulo Selecionado

Este módulo contém as operações aritméticas básicas com as verificações de excedentes.

módulo OperatorIntrinsics

Um módulo de funções intrínsecas do compilador para implementações eficientes inteiro de F# varia e invocações dinâmicos de outros operadores de F#

módulo Não Selecionado

Este módulo contém as operações básicas que não se aplicam verificações de tempo de execução e/ou estático

Valores

Valor

Descrição

( ! ) : 'T ref -> 'T

Desreferenciar uma célula de referência mutável.

( % ) : ^T1 -> ^T2 -> ^T3

Operador sobrecarregado de modulo.

( &&& ) : ^T -> ^T -> ^T

Bit a bit sobrecarregado E operador.

( * ) : ^T1 -> ^T2 -> ^T3

Operador sobrecarregado de multiplicação.

( ** ) : ^T -> ^U -> ^T

Operador sobrecarregado exponentiation.

( + ) : ^T1 -> ^T2 -> ^T3

Operador sobrecarregado de adição.

( - ) : ^T1 -> ^T2 -> ^T3

Operador de subtração sobrecarregados.

( .. ) : ^T -> ^T -> seq<^T>

O padrão tenha sobrecarregado o operador do intervalo, por..exemplo o[n..m] para listas, seq {n..m} para seqüências.

( .. .. ) : ^T -> ^Step -> ^T -> seq<^T>

O padrão tenha sobrecarregado o operador de intervalo skip por exemplo.., o[n..skip..m] para listas, seq {n..skip..m} para seqüências.

( / ) : ^T1 -> ^T2 -> ^T3

Operador sobrecarregado de divisão.

( := ) : 'T ref -> 'T -> unit

Atribui a uma célula de referência mutável.

( < ) : 'T -> 'T -> bool

Estruturalmente símbolo de menor que a comparação.

( << ) : ('T2 -> 'T3) -> ('T1 -> 'T2) -> 'T1 -> 'T3

Compondo duas funções, a função à direita que está sendo aplicado primeiro.

( <<< ) : ^T -> int32 -> ^T

A bytes SHIFT sobrecarregada à esquerda do operador por um número especificado de bits.

( <= ) : 'T -> 'T -> bool

Comparação igual ou menor estrutural.

(<>): 'T -> 'T -> bool

Desigualdade estrutural.

(<| ): ('T -> 'U) -> 'T -> 'U

Aplicar uma função a um valor, o valor que está à direita, a função à esquerda.

(<|| ): ('T1 -> 'T2 -> 'U) -> 'T1 * 'T2 -> 'U

Aplicar uma função como dois valores, os valores que são um par para a direita, a função à esquerda.

(<||| ): ('T1 -> 'T2 -> 'T3 -> 'U) -> 'T1 * 'T2 * 'T3 -> 'U

Aplicar uma função em três valores, os valores que são triplicar-se à direita, a função à esquerda.

( = ) : 'T -> 'T -> bool

Estruturalmente igualdade.

(>): 'T -> 'T -> bool

Estruturalmente grande- de.

(>=): 'T -> 'T -> bool

Grande-do que-ou-igual estrutural.

(>>): ('T1 -> 'T2) -> ('T2 -> 'T3) -> 'T1 -> 'T3

Compondo duas funções, a função à esquerda que está sendo aplicado primeiro.

(>>>): ^T -> int32 -> ^T

Operador sobrecarregado da direita de bytes) por um número especificado de bits.

( @ ) : 'T list -> 'T list -> 'T list

Concatena duas listas.

( ^ ) : string -> string -> string

Concatena duas cadeias de caracteres.O operador “+” também pode ser usado.

( ^^^ ) : ^T -> ^T -> ^T

Operador bit a bit sobrecarregado XOR.

( |>): 'T1 -> ('T1 -> 'U) -> 'U

Aplicar uma função a um valor, o valor que está à esquerda, a função à direita.

( ||>): 'T1 * 'T2 -> ('T1 -> 'T2 -> 'U) -> 'U

Aplicar uma função como dois valores, os valores que são um par à esquerda, a função à direita.

( ||| ) : ^T -> ^T -> ^T

Operador OR bit a bit sobrecarregado

( |||>): 'T1 * 'T2 * 'T3 -> ('T1 -> 'T2 -> 'T3 -> 'U) -> 'U

Aplicar uma função em três valores, os valores que são triplicar-se à esquerda, a função à direita.

( ~+ ) : ^T -> ^T

Prefixo mais o operador sobrecarregado.

( ~- ) : ^T -> ^T

Negação unário sobrecarregada.

( ~~~ ) : ^T -> ^T

Operador NOT bit a bit sobrecarregado.

Abs: ^T -> ^T

Valor absoluto de um número determinado.

ACOS: ^T -> ^T

Arcocosseno de número determinado.

ASIN: ^T -> ^T

Arcoseno de número determinado.

atan: ^T -> ^T

Arcotangente inverso de número determinado.

atan2: ^T1 -> ^T2 -> 'T2

Arcotangente oposto de x/y onde x e y são especificados separadamente.

a caixa: 'T -> obj

Encaixota fortemente um valor tipado.

byte: ^T -> byte

Converte o argumento para o byte.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

ceil: ^T -> ^T

Teto de número determinado.

char: ^T -> char

Converte o argumento para o caractere.Entradas numéricas são convertidas de acordo com a codificação UTF-16 para caracteres.As entradas de cadeia de caracteres devem ser exatamente um caractere tempo.Para outros tipos de entrada a operação de conversão requer um método estático apropriado no tipo de entrada.

compare: 'T -> 'T -> int

Comparação genérico.

cos: ^T -> ^T

Cosseno do número determinado.

COSH: ^T -> ^T

Cosseno hiperbólico de número determinado.

decimal: ^T -> decimal

Converte o argumento para Decimal usando uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

decr: int ref -> unit

Decresça uma referência mutável células contendo um número inteiro.

defaultArg: 'T option -> 'T -> 'T

Usado para especificar um valor padrão para um argumento opcional na implementação de uma função.

enum: int32 -> ^U

Converte o argumento para um tipo específico de enum .

saída: int -> 'T

Sair de hardware o processo atual isolado, se as configurações de segurança permitem, se não geram uma exceção.Chama Exit.

exp: ^T -> ^T

Exponencialmente de número determinado.

falha: string -> exn

Cria um objeto de Exception .

failwith: string -> 'T

Lance uma exceção de Exception .

float : ^T -> float

Converte o argumento para o flutuante de 64 bits.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

float32: ^T -> float32

Converte o argumento para o flutuante de 32 bits.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

andar: ^T -> ^T

Andar de número determinado.

fst: 'T1 * 'T2 -> 'T1

Retorna o primeiro elemento de um tuple, fst (a,b) = a.

hash: 'T -> int

Uma função de hash genérico, projetado para retornar valores de hash iguais para itens que são iguais de acordo com o operador de = .Por padrão usará hashing estrutural para a união de F#, o registro e os tipos de tuple, hashing o conteúdo completo do tipo.O comportamento exato de função pode ser definido em uma base de tipo-por- tipo implementando GetHashCode para cada tipo.

identificação: 'T -> 'T

a função de identidade.

ignorar: 'T -> unit

Ignorar o valor passado.Isso é freqüentemente usado para lançar possam resultados de uma computação.

aumento: int ref -> unit

Incrementar uma referência mutável células contendo um número inteiro.

infinito: float

Equivalente a PositiveInfinity.

infinityf: float32

Equivalente a PositiveInfinity.

int : ^T -> int

Converte o argumento para o inteiro de 32 bits com sinal.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

int16: ^T -> int16

Converte o argumento para o inteiro de 16 bits com sinal.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

int32: ^T -> int32

Converte o argumento para o inteiro de 32 bits com sinal.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse) com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

int64: ^T -> int64

Converte o argumento para o inteiro de 64 bits com sinal.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

invalidArg: string -> string -> 'T

Lance uma exceção de ArgumentException .

invalidOp: string -> 'T

Lance uma exceção de InvalidOperationException .

limitedHash: int -> 'T -> int

Uma função de hash genérico.Essa função tem o mesmo comportamento que hash, mas ele hashing estrutural padrão para a união, o registro e o tuple de F# tipos pára quando o limite dado de nós é alcançado.O comportamento exato de função pode ser definido em uma base de tipo-por- tipo implementando GetHashCode para cada tipo.

bloqueio: 'Lock -> (unit -> 'T) -> 'T

Executar a função como uma região de mútuo- exclusão usando o valor de entrada como um bloqueio.

log: ^T -> ^T

Logaritmo natural de número determinado.

log10: ^T -> ^T

Logaritmo para basear 10 do número determinado.

máximo: 'T -> 'T -> 'T

Máximo baseado na comparação genérico.

minuto: 'T -> 'T -> 'T

Mínimo com base na comparação genérico.

nan: float

Equivalente a NaN.

nanf: float32

Equivalente a NaN.

nativeint: ^T -> nativeint

Converte o argumento nativo para inteiro com sinal.Esta é uma conversão direta para todos os tipos numéricos primitivos.Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

não: bool -> bool

Negue um valor lógico.

nullArg: string -> 'T

Lance uma exceção de ArgumentNullException .

pown: ^T -> int -> ^T

Operador sobrecarregado de energia.Se equivalente de n > 0 na x*...*x por ocorrências de n de x.

aumento: Exception -> 'T

Gera uma exceção.

referência: 'T -> 'T ref

Crie uma célula de referência mutável.

reraise: unit -> 'T

Rethrows uma exceção.Isso só deve ser usado ao manipular uma exceção.

redondo: ^T -> ^T

Em volta de número determinado.

sbyte: ^T -> sbyte

Converte o argumento para o byte assinado.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

segs.: seq<'T> -> seq<'T>

Cria uma seqüência usando a sintaxe de expressões de seqüência.

sinal: ^T -> int

Sinal de número determinado.

seno: ^T -> ^T

Seno de número determinado.

SINH: ^T -> ^T

Seno hiperbólico de número determinado.

sizeof: int

Retorna o tamanho de um tipo interno em bytes.Por exemplo, retornará 4. de sizeof<int> .

e: 'T1 * 'T2 -> 'T2

Retornar o segundo elemento de um tuple, snd (a,b) = b.

sqrt: ^T -> ^T

Raiz quadrada de determinado número.

stderr: TextWriter

Ler o valor da propriedade Error.

stdin: TextReader

Ler o valor da propriedade In.

stdout: TextWriter

Ler o valor da propriedade Out.

cadeia de caracteres: ^T -> string

Converte o argumento para uma cadeia de caracteres usando ToString.

bronzeado: ^T -> ^T

Tangente de número determinado.

TANH: ^T -> ^T

Arcotangente hiperbólica de número determinado.

truncado: ^T -> ^T

Operador sobrecarregado truncado.

typedefof: Type

Gere uma representação de Type de uma definição de tipo.Se o tipo de entrada é uma instanciação de tipo genérico então retorna a definição de tipo genérico associada com todas essas instanciações.

typeof: Type

Gere uma representação em tempo de execução de Type de um tipo estático.O tipo estático é mantido ainda no valor retornado.

uint16: ^T -> uint16

Converte o argumento para o inteiro de 16 bits sem sinal.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

uint32: ^T -> uint32

Converte o argumento para o inteiro de 32 bits sem sinal.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

uint64: ^T -> uint64

Converte o argumento para o inteiro de 64 bits sem sinal.Esta é uma conversão direta para todos os tipos numéricos primitivos.Para cadeias de caracteres, a entrada é convertida usando Parse com configurações de InvariantCulture .Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

unativeint: ^T -> nativeint

Converte o argumento para inteiro sem sinal nativo usando uma conversão direta para todos os tipos numéricos primitivos.Se a operação não requer um método de conversão estático apropriado no tipo de entrada.

desencapsular: obj -> 'T

Unboxes fortemente um valor tipado.Este é o inverso de boxiguais, ade unbox<'T>(box<'T> a) .

Usando : 'T -> ('T -> 'U) -> 'U

Limpar os recursos associados com o objeto de entrada após a conclusão de função especificados.Limpeza mesmo quando ocorre uma exceção é gerada pelo código protegido.

Padrões ativos

Padrão ativo

Descrição

( |falha|_| ): exn -> string option

Corresponde aos objetos de Exception cujo tipo em tempo de execução é precisamente Exception.

( |KeyValue| ): KeyValuePair<'Key,'Value> -> 'Key * 'Value

Um padrão ativo para os valores do tipo KeyValuePair<TKey, TValue>

Plataformas

O windows 8, Windows 7, Windows Server 2012, Windows Server 2008 R2

Informações de Versão

Versões da biblioteca principal de F#

Suportado em: 2,0, 4,0, portáteis

Consulte também

Referência

Microsoft.FSharp.Core Namespace (F#)